@mario_hahn/jumpy-ui 0.5.0

package/dist/jumpy-theme-inventory.js

@@ -0,0 +1,6 @@
+import {
+  jumpyThemeInventory
+} from "./chunk-XDTVYUWG.js";
+export {
+  jumpyThemeInventory
+};

package/dist/theme.js

@@ -0,0 +1,59 @@
+"use client";
+import {
+  JumpyAnimation,
+  JumpyAnimationDelay,
+  JumpyAnimationDuration,
+  JumpyBorderWidth,
+  JumpyOpacity,
+  JumpyRadius,
+  JumpyShadowStyle,
+  JumpySize,
+  JumpySpacing,
+  JumpyTextStyle,
+  JumpyThemeProvider,
+  animationDelayValue,
+  animationDurationValue,
+  animationEasingValue,
+  borderWidthValue,
+  createJumpyTheme,
+  createJumpyThemeFromPreset,
+  defaultJumpyTheme,
+  jumpyThemePresets,
+  opacityValue,
+  radiusValue,
+  shadowValue,
+  sizeValue,
+  spacingValue,
+  textStyleValue,
+  themeToCSSVariables,
+  useJumpyTheme
+} from "./chunk-5QINBZIU.js";
+export {
+  JumpyAnimation,
+  JumpyAnimationDelay,
+  JumpyAnimationDuration,
+  JumpyBorderWidth,
+  JumpyOpacity,
+  JumpyRadius,
+  JumpyShadowStyle,
+  JumpySize,
+  JumpySpacing,
+  JumpyTextStyle,
+  JumpyThemeProvider,
+  animationDelayValue,
+  animationDurationValue,
+  animationEasingValue,
+  borderWidthValue,
+  createJumpyTheme,
+  createJumpyThemeFromPreset,
+  defaultJumpyTheme,
+  jumpyThemePresets,
+  opacityValue,
+  radiusValue,
+  shadowValue,
+  sizeValue,
+  spacingValue,
+  textStyleValue,
+  themeToCSSVariables,
+  useJumpyTheme
+};

package/dist/utils.js

@@ -0,0 +1,6 @@
+import {
+  cn
+} from "./chunk-3DBKYKP2.js";
+export {
+  cn
+};

package/index.d.ts

@@ -0,0 +1,141 @@
+import type { AnchorHTMLAttributes, ButtonHTMLAttributes, HTMLAttributes, InputHTMLAttributes, ReactNode, Ref, TdHTMLAttributes, TextareaHTMLAttributes, ThHTMLAttributes } from 'react'
+export type { JumpyTheme } from './theme.js'
+type ElementTag = keyof HTMLElementTagNameMap
+type JumpResponsiveValue<T> = T | { small?: T; medium?: T; large?: T; xLarge?: T }
+type JumpGridSpacing = number | string | [row: number | string, column: number | string]
+type JumpInnerClass = { className?: string; style?: import('react').CSSProperties }
+type JumpButtonSlots = { leading?: ReactNode; trailing?: ReactNode }
+type JumpCardInnerClasses = Partial<Record<'checkmark' | 'checkmarkIcon', JumpInnerClass>>
+type JumpPolymorphicButtonAttributes = ButtonHTMLAttributes<HTMLButtonElement> & AnchorHTMLAttributes<HTMLAnchorElement>
+type JumpInputStatus = 'regular' | 'alarm'
+type JumpBaseInputSlots = { leading?: ReactNode; trailing?: ReactNode; helperText?: ReactNode }
+type JumpSwitchInnerClasses = Partial<Record<'container' | 'input' | 'track' | 'thumb' | 'icon', JumpInnerClass>>
+type JumpRadioInnerClasses = Partial<Record<'container' | 'input' | 'label', JumpInnerClass>>
+type JumpListItemSlots = { selector?: ReactNode; leading?: ReactNode; label?: ReactNode; description?: ReactNode; metadata?: ReactNode; trailing?: ReactNode; nestedList?: ReactNode }
+type JumpListItemInnerClasses = Partial<Record<'selector' | 'leading' | 'label' | 'description' | 'metadata' | 'trailing' | 'expander' | 'decoratorContainer' | 'collapsedLabel' | 'expanderIcon', JumpInnerClass>>
+type JumpSideMenuRenderMode = 'flat' | 'navigation'
+type JumpTooltipOptions = HTMLAttributes<HTMLSpanElement> & { content: ReactNode }
+export declare const jumpyThemeInventory: Record<string, unknown>
+export declare const SORT_ORDER: { readonly DEFAULT: 'default'; readonly ASC: 'asc'; readonly DESC: 'desc' }
+export declare const KeyboardKeys: { readonly ARROW_DOWN: 'ArrowDown'; readonly ARROW_LEFT: 'ArrowLeft'; readonly ARROW_RIGHT: 'ArrowRight'; readonly ARROW_UP: 'ArrowUp'; readonly END: 'End'; readonly ENTER: 'Enter'; readonly ESCAPE: 'Escape'; readonly HOME: 'Home'; readonly SPACE: ' '; readonly TAB: 'Tab' }
+export {
+  JumpyThemeProvider,
+  createJumpyTheme,
+  createJumpyThemeFromPreset,
+  defaultJumpyTheme,
+  jumpyThemePresets,
+  themeToCSSVariables,
+  useJumpyTheme,
+  JumpyAnimation,
+  JumpyAnimationDelay,
+  JumpyAnimationDuration,
+  JumpyBorderWidth,
+  JumpyOpacity,
+  JumpyRadius,
+  JumpyShadowStyle,
+  JumpySize,
+  JumpySpacing,
+  JumpyTextStyle,
+  animationDelayValue,
+  animationDurationValue,
+  animationEasingValue,
+  borderWidthValue,
+  opacityValue,
+  radiusValue,
+  shadowValue,
+  sizeValue,
+  spacingValue,
+  textStyleValue,
+} from './theme.js'
+
+export declare function JumpBackground(props: { snow?: boolean }): ReactNode
+export declare function JumpBadge(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; size?: 'xSmall' | 'small' | 'medium'; status?: 'regular' | 'positive' | 'warning' | 'alarm' | 'active'; hidden?: boolean; children?: ReactNode }): ReactNode
+export declare function BrandMark(props: { compact?: boolean; label?: string }): ReactNode
+export declare function JumpCard(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; children: ReactNode; variant?: 'filled' | 'outlined'; interactive?: boolean; selected?: boolean; disabled?: boolean; dragged?: boolean; innerClasses?: JumpCardInnerClasses }): ReactNode
+export declare function JumpGrid(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; columns?: JumpResponsiveValue<number | string>; spacing?: JumpResponsiveValue<JumpGridSpacing>; children?: ReactNode }): ReactNode
+export declare function JumpGridItem(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; span?: JumpResponsiveValue<number>; horizontalPlacement?: 'start' | 'center' | 'end' | 'stretch'; verticalPlacement?: 'start' | 'center' | 'end' | 'stretch'; children?: ReactNode }): ReactNode
+export declare function JumpList(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; children: ReactNode }): ReactNode
+export declare function JumpListItem(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; ref?: Ref<HTMLElement>; children: ReactNode; selected?: boolean; disabled?: boolean; readOnly?: boolean; focusedView?: boolean; leading?: ReactNode; trailing?: ReactNode; metadata?: ReactNode; description?: ReactNode; slots?: JumpListItemSlots; nestedCollapsed?: boolean; defaultNestedCollapsed?: boolean; onNestedCollapsedChange?: (nestedCollapsed: boolean) => void; truncateTexts?: boolean; innerClasses?: JumpListItemInnerClasses }): ReactNode
+export type JumpSideMenuItemValue = string | number
+export type JumpSideMenuItemSlots = { metadata?: ReactNode; nestedMenu?: ReactNode }
+export declare function JumpSideMenu(props: Omit<HTMLAttributes<HTMLElement>, 'onChange'> & { as?: ElementTag; children: ReactNode; selected?: JumpSideMenuItemValue[]; disabled?: boolean; disableKeyboardNavigation?: boolean; collapsed?: boolean; renderMode?: JumpSideMenuRenderMode; getItemProps?: (userProps?: Record<string, unknown>) => Record<string, unknown>; onChange?: (value: JumpSideMenuItemValue[]) => void }): ReactNode
+export declare function JumpSideMenuItem(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; value?: JumpSideMenuItemValue; children?: ReactNode; selected?: boolean; disabled?: boolean; collapsed?: boolean; icon?: ReactNode | ((state: { selected: boolean }) => ReactNode); badge?: ReactNode | ((state: { selected: boolean; collapsed: boolean }) => ReactNode); metadata?: ReactNode; description?: ReactNode; nestedMenu?: ReactNode; slots?: JumpSideMenuItemSlots; nestedCollapsed?: boolean; defaultNestedCollapsed?: boolean; onNestedCollapsedChange?: (nestedCollapsed: boolean) => void; renderMode?: JumpSideMenuRenderMode; focusedView?: boolean; truncateTexts?: boolean; tooltipProps?: JumpTooltipOptions; innerClasses?: JumpListItemInnerClasses; wrapperProps?: HTMLAttributes<HTMLLIElement>; expanderIconProps?: HTMLAttributes<HTMLElement> }): ReactNode
+export declare function JumpTypography(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; variant?: string; color?: 'primary' | 'secondary' | string; children: ReactNode }): ReactNode
+export declare function JumpHyperlink(props: AnchorHTMLAttributes<HTMLAnchorElement> & { as?: ElementTag; variant?: 'inline' | 'button'; disabled?: boolean; children: ReactNode }): ReactNode
+export declare function JumpDivider(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; direction?: 'horizontal' | 'vertical'; captionPosition?: 'start' | 'center' | 'end'; children?: ReactNode }): ReactNode
+export declare function JumpAvatar(props: ButtonHTMLAttributes<HTMLButtonElement> & { as?: ElementTag; size?: 'small' | 'medium' | 'large'; disableInteraction?: boolean; disabled?: boolean; children?: ReactNode }): ReactNode
+export type JumpBannerInnerPart = 'status' | 'contentContainer' | 'content' | 'contentTitle' | 'contentDescription' | 'actionsContainer'
+export type JumpBannerInnerClasses = Partial<Record<JumpBannerInnerPart, { className?: string; style?: import('react').CSSProperties }>>
+export declare function JumpBanner(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; status?: 'info' | 'positive' | 'warning' | 'alarm' | 'other'; variant?: 'default' | 'inline'; direction?: 'horizontal' | 'vertical'; hideStatus?: boolean; floating?: boolean; title?: ReactNode; actions?: ReactNode; slots?: { title?: ReactNode; actions?: ReactNode; icon?: ReactNode }; innerClasses?: JumpBannerInnerClasses; children?: ReactNode }): ReactNode
+export declare function JumpSkeletonLoader(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; variant?: 'text' | 'icon' | 'avatar' | 'rectangular'; lines?: number; width?: number | string; height?: number | string; disableAnimation?: boolean; children?: ReactNode }): ReactNode
+export declare const JumpSearchField: import('react').ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> & { label?: string } & import('react').RefAttributes<HTMLInputElement>>
+export declare function JumpTooltip(props: HTMLAttributes<HTMLSpanElement> & { content: ReactNode; children: ReactNode }): ReactNode
+export declare function JumpPopover(props: HTMLAttributes<HTMLSpanElement> & { open?: boolean; defaultOpen?: boolean; onOpenChange?: (open: boolean) => void; trigger: ReactNode; children: ReactNode }): ReactNode
+export declare function JumpMenu(props: HTMLAttributes<HTMLDivElement> & { trigger: ReactNode; open?: boolean; defaultOpen?: boolean; onOpenChange?: (open: boolean) => void; header?: ReactNode; footer?: ReactNode; placement?: 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end'; children: ReactNode }): ReactNode
+export declare function JumpMenuItem(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; children: ReactNode; selected?: boolean; disabled?: boolean; readOnly?: boolean; focusedView?: boolean; leading?: ReactNode; trailing?: ReactNode; metadata?: ReactNode; description?: ReactNode; slots?: JumpListItemSlots; nestedMenu?: ReactNode }): ReactNode
+export type JumpToggleButtonValue = string | number
+export declare function JumpToggleButton(props: Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'> & { as?: ElementTag; selected?: boolean; value?: JumpToggleButtonValue; onChange?: (selected: boolean) => void; leading?: ReactNode | ((state: { selected: boolean }) => ReactNode); children?: ReactNode }): ReactNode
+export declare function JumpToggleButtonGroup<TValue extends JumpToggleButtonValue = JumpToggleButtonValue>(props: Omit<HTMLAttributes<HTMLElement>, 'onChange'> & { as?: ElementTag; selected?: Array<TValue>; defaultSelected?: Array<TValue>; onChange?: (selected: Array<TValue>) => void; exclusive?: boolean; disabled?: boolean; children?: ReactNode }): ReactNode
+export declare function JumpPinInput(props: Omit<HTMLAttributes<HTMLFieldSetElement>, 'onChange'> & { length?: number; value?: string; defaultValue?: string; onChange?: (value: string) => void; onComplete?: (value: string) => void; name?: string; mask?: boolean; type?: 'numeric' | 'alphanumeric'; error?: boolean; disabled?: boolean; helperText?: ReactNode; ariaLabels?: { cell?: (index: number, length: number) => string }; innerClasses?: Partial<Record<'cells' | 'cell' | 'supportingText', { className?: string; style?: import('react').CSSProperties }>> }): ReactNode
+export declare function JumpPageControl(props: HTMLAttributes<HTMLDivElement> & { totalPages?: number; currentPage?: number; defaultPage?: number; maxVisibleDots?: number; disabled?: boolean; disabledPages?: number[]; disableInteraction?: boolean; onPageChange?: (page: number) => void; pageAriaLabels?: string[] }): ReactNode
+export type JumpSnackbarPosition = 'top-start' | 'top-center' | 'top-end' | 'bottom-start' | 'bottom-center' | 'bottom-end'
+export type JumpSnackbarData = { status?: 'info' | 'positive' | 'warning' | 'alarm' | 'other'; title?: ReactNode; description?: ReactNode; slots?: { actions?: ReactNode }; duration?: number; persistent?: boolean }
+export type JumpSnackbarOptions = { id?: string; duration?: number; persistent?: boolean }
+export declare function useJumpSnackbar(): { addSnackbar: (contentOrData: ReactNode | JumpSnackbarData, options?: JumpSnackbarOptions) => string; removeSnackbar: (id: string) => void; clearAll: () => void; snackbars: Array<unknown> }
+export declare function JumpSnackbarProvider(props: HTMLAttributes<HTMLDivElement> & { position?: JumpSnackbarPosition; maxSnackbars?: number; offset?: { top?: number; right?: number; bottom?: number; left?: number }; children?: ReactNode }): ReactNode
+export type JumpExpandableInnerClasses = Partial<Record<'header' | 'headerContent' | 'label' | 'description' | 'icon' | 'panel', { className?: string; style?: import('react').CSSProperties }>>
+export declare function JumpExpandable(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; variant?: 'filled' | 'outlined'; disabled?: boolean; expanded?: boolean; defaultExpanded?: boolean; onChange?: (expanded: boolean) => void; slots?: { leading?: ReactNode; label?: ReactNode; description?: ReactNode; trailing?: ReactNode }; innerClasses?: JumpExpandableInnerClasses; children?: ReactNode }): ReactNode
+export declare function JumpExpandableGroup(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; multiple?: boolean; disabled?: boolean; headingLevel?: 1 | 2 | 3 | 4 | 5 | 6; onChange?: (expandedIndices: number[]) => void; innerClasses?: { divider?: { className?: string; style?: import('react').CSSProperties } }; children?: ReactNode }): ReactNode
+export type JumpTableAlign = 'start' | 'center' | 'end' | 'justify' | 'inherit'
+export type JumpTablePinned = false | 'left' | 'right'
+export type JumpTableSortOrder = 'default' | 'asc' | 'desc' | 'none' | 'ascending' | 'descending'
+export interface JumpSelectableRow { id: string | number; getIsSelected: () => boolean; getIsSomeSelected: () => boolean; getCanSelect: () => boolean; toggleSelected: (value?: boolean, opts?: { selectChildren?: boolean }) => void; subRows?: JumpSelectableRow[]; depth?: number }
+export interface JumpSelectableTable { getIsAllRowsSelected: () => boolean; getIsSomeRowsSelected: () => boolean; getToggleAllRowsSelectedHandler: () => (event: unknown) => void; getRowModel?: () => { rows: JumpSelectableRow[] } }
+export interface JumpSelectionCheckboxProps { checked: boolean; indeterminate?: boolean; disabled?: boolean; 'aria-label': string; onChange: (event: unknown) => void }
+export declare function getSortMapping<T>(currentOrder: false | JumpTableSortOrder, ascValue: T, descValue: T, defaultValue: T): T
+export declare function getNextSortOrder(currentOrder: JumpTableSortOrder): 'asc' | 'desc' | 'default'
+export declare function getSortOrder(sortDirection: false | 'asc' | 'desc'): 'asc' | 'desc' | 'default'
+export declare function getSortActionLabel(currentOrder: JumpTableSortOrder, columnName?: string): string
+export declare function isRowFullySelected(row: JumpSelectableRow): boolean
+export declare function applySubtreeSelection(row: JumpSelectableRow, selected: boolean): void
+export declare function getRowCheckboxProps(row: JumpSelectableRow, disabled?: boolean): JumpSelectionCheckboxProps
+export declare function getHeaderCheckboxProps(table: JumpSelectableTable, disabled?: boolean): JumpSelectionCheckboxProps
+export type JumpTableInnerClasses = { wrapper?: { className?: string; style?: import('react').CSSProperties } }
+export type JumpTableCellInnerClasses = Partial<Record<'inner' | 'leading' | 'content' | 'text' | 'description' | 'trailing' | 'label' | 'labelText' | 'sortButton' | 'sortIndicator', { className?: string; style?: import('react').CSSProperties }>>
+export declare function JumpTable(props: HTMLAttributes<HTMLTableElement> & { ref?: Ref<HTMLTableElement>; showHorizontalBorders?: boolean; disabled?: boolean; stickyHeader?: boolean; density?: 'default' | 'regular' | 'condensed'; containerProps?: HTMLAttributes<HTMLDivElement> & { ref?: Ref<HTMLDivElement> }; innerClasses?: JumpTableInnerClasses; children?: ReactNode }): ReactNode
+export declare function JumpTableHead(props: HTMLAttributes<HTMLTableSectionElement> & { as?: ElementTag; ref?: Ref<HTMLTableSectionElement>; children?: ReactNode }): ReactNode
+export declare function JumpTableBody(props: HTMLAttributes<HTMLTableSectionElement> & { as?: ElementTag; ref?: Ref<HTMLTableSectionElement>; children?: ReactNode }): ReactNode
+export declare function JumpTableFooter(props: HTMLAttributes<HTMLTableSectionElement> & { as?: ElementTag; ref?: Ref<HTMLTableSectionElement>; children?: ReactNode }): ReactNode
+export declare function JumpTableRow(props: HTMLAttributes<HTMLTableRowElement> & { as?: ElementTag; ref?: Ref<HTMLTableRowElement>; selected?: boolean; disabled?: boolean; disableHover?: boolean; verticalAlign?: 'middle' | 'top'; dragging?: boolean; children?: ReactNode }): ReactNode
+export declare function JumpTableCell(props: Omit<TdHTMLAttributes<HTMLTableCellElement>, 'align'> & { as?: ElementTag; ref?: Ref<HTMLTableCellElement>; selected?: boolean; disabled?: boolean; align?: JumpTableAlign; variant?: 'default' | 'control'; padding?: 'default' | 'none' | 'checkbox'; showHorizontalBorder?: boolean; pinned?: JumpTablePinned; pinnedEdge?: boolean; leading?: ReactNode; trailing?: ReactNode; description?: ReactNode; slots?: { leading?: ReactNode; trailing?: ReactNode; description?: ReactNode }; innerClasses?: JumpTableCellInnerClasses; children?: ReactNode }): ReactNode
+export declare function JumpTableHeaderCell(props: Omit<ThHTMLAttributes<HTMLTableCellElement>, 'align'> & { as?: ElementTag; ref?: Ref<HTMLTableCellElement>; selected?: boolean; disabled?: boolean; align?: JumpTableAlign; variant?: 'default' | 'control'; padding?: 'default' | 'none' | 'checkbox'; showHorizontalBorder?: boolean; pinned?: JumpTablePinned; pinnedEdge?: boolean; sortable?: boolean; sortOrder?: JumpTableSortOrder; onSortChange?: (sortOrder: JumpTableSortOrder) => void; ariaLabels?: { sort?: string | ((sortOrder: JumpTableSortOrder) => string) }; leading?: ReactNode; trailing?: ReactNode; slots?: { leading?: ReactNode; trailing?: ReactNode }; innerClasses?: JumpTableCellInnerClasses; children?: ReactNode }): ReactNode
+export declare function JumpSheet(props: HTMLAttributes<HTMLElement> & { visible?: boolean; onVisibleChange?: (visible: boolean) => void; position?: 'top' | 'right' | 'bottom' | 'left'; title?: string; subtitle?: string; footer?: ReactNode; children?: ReactNode }): ReactNode
+export declare function JumpSectionHeader(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; variant?: 'regular' | 'prominent'; description?: ReactNode; children: ReactNode }): ReactNode
+export declare function JumpSectionFooter(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; children: ReactNode }): ReactNode
+export declare function JumpTag(props: HTMLAttributes<HTMLSpanElement> & { size?: 'small' | 'medium'; status?: 'regular' | 'positive' | 'warning' | 'alarm'; disabled?: boolean; children: ReactNode }): ReactNode
+export declare function JumpChip(props: ButtonHTMLAttributes<HTMLButtonElement> & { selected?: boolean; disabled?: boolean; children: ReactNode }): ReactNode
+export declare function JumpCheckbox(props: Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'type' | 'children'> & { label?: ReactNode; children?: ReactNode; checked?: boolean; defaultChecked?: boolean; indeterminate?: boolean; onCheckedChange?: (checked: boolean) => void; onIndeterminateChange?: (indeterminate: boolean) => void; disabled?: boolean; readOnly?: boolean; labelPlacement?: 'start' | 'end'; innerClasses?: Partial<Record<'container' | 'input' | 'icons', { className?: string; style?: import('react').CSSProperties }>> }): ReactNode
+export declare function JumpSwitch(props: Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'type' | 'role' | 'children'> & { label?: ReactNode; children?: ReactNode; checked?: boolean; defaultChecked?: boolean; onChange?: (event: unknown) => void; onCheckedChange?: (checked: boolean) => void; disabled?: boolean; readOnly?: boolean; labelPlacement?: 'start' | 'end'; innerClasses?: JumpSwitchInnerClasses }): ReactNode
+export declare function JumpRadioGroup(props: HTMLAttributes<HTMLDivElement> & { name?: string; value?: string; defaultValue?: string; onValueChange?: (value: string) => void; disabled?: boolean; readOnly?: boolean; direction?: 'horizontal' | 'vertical'; innerClasses?: JumpRadioInnerClasses; options: Array<{ value: string; label: ReactNode; disabled?: boolean }> }): ReactNode
+export type JumpDropdownItemValue = string | number
+export interface JumpDropdownItem<TValue extends JumpDropdownItemValue = JumpDropdownItemValue> { label: string; value: TValue; children?: Array<JumpDropdownItem<TValue>>; metadata?: Record<string, unknown>; disabled?: boolean }
+export declare function JumpDropdown<TValue extends JumpDropdownItemValue = JumpDropdownItemValue>(props: Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange'> & { label?: string; hint?: string; value?: Array<TValue>; defaultValue?: Array<TValue>; open?: boolean; onChange?: (value: Array<TValue>) => void; onOpenChange?: (open: boolean) => void; items?: Array<JumpDropdownItem<TValue>>; placeholder?: string; disabled?: boolean; multiple?: boolean; searchable?: boolean; renderTrigger?: (selectedValues: Array<TValue>, isOpen: boolean) => ReactNode; renderItem?: (option: JumpDropdownItem<TValue>, selected: boolean, listItemProps: Record<string, unknown>) => ReactNode; inputRef?: import('react').Ref<HTMLInputElement>; status?: 'regular' | 'alarm'; error?: boolean; hideClearIcon?: boolean; onClear?: () => void }): ReactNode
+export type JumpDateTimeValue = Date | number
+export declare function JumpDatePicker<TValue extends JumpDateTimeValue = Date>(props: Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange'> & { label?: string; hint?: string; value?: TValue | null; defaultValue?: TValue | null; onChange?: (value: TValue | null) => void; open?: boolean; onOpenChange?: (open: boolean) => void; format?: string | string[]; minDate?: TValue; maxDate?: TValue; disabledDates?: TValue[]; isDateDisabled?: (date: Date) => boolean; labels?: { cancelButton?: string; applyButton?: string }; disabled?: boolean; readOnly?: boolean; status?: 'regular' | 'alarm'; error?: boolean; hideClearIcon?: boolean; onClear?: () => void }): ReactNode
+export declare function JumpTimePicker<TValue extends JumpDateTimeValue = Date>(props: Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange'> & { label?: string; hint?: string; value?: TValue | null; defaultValue?: TValue | null; onChange?: (value: TValue | null) => void; open?: boolean; onOpenChange?: (open: boolean) => void; format?: string; twentyFourHours?: boolean; labels?: { cancelButton?: string; applyButton?: string }; disabled?: boolean; readOnly?: boolean; status?: 'regular' | 'alarm'; error?: boolean; hideClearIcon?: boolean; onClear?: () => void }): ReactNode
+export declare function JumpSpinner(props: HTMLAttributes<SVGSVGElement> & { size?: 'xSmall' | 'small' | 'medium' | 'large' | 'xLarge' | 'xxLarge'; mode?: 'determinate' | 'indeterminate'; value?: number; showTrack?: boolean; inverse?: boolean }): ReactNode
+export type JumpDialogInnerPart = 'illustration' | 'body' | 'icon' | 'title' | 'scrollableContent' | 'description' | 'footer'
+export type JumpDialogInnerClasses = Partial<Record<JumpDialogInnerPart, { className?: string; style?: import('react').CSSProperties }>>
+export declare function JumpDialog(props: HTMLAttributes<HTMLElement> & { as?: ElementTag; visible?: boolean; onVisibleChange?: (visible: boolean) => void; title?: ReactNode; description?: ReactNode; footer?: ReactNode; disableBackdropClick?: boolean; disableContentScroll?: boolean; fullScreen?: boolean; overlayProps?: HTMLAttributes<HTMLDivElement>; slots?: { illustration?: ReactNode; icon?: ReactNode; title?: ReactNode; description?: ReactNode; footer?: ReactNode }; innerClasses?: JumpDialogInnerClasses; children?: ReactNode }): ReactNode
+export declare function JumpLoader(props: { label?: string; fullScreen?: boolean; className?: string; decorativeBackground?: boolean }): ReactNode
+export declare function JumpButton(props: JumpPolymorphicButtonAttributes & { as?: ElementTag; variant?: 'primary' | 'secondary' | 'tertiary' | 'borderless'; status?: 'regular' | 'alarm'; isLoading?: boolean; elevated?: boolean; slots?: JumpButtonSlots; leadingIcon?: ReactNode; trailingIcon?: ReactNode }): ReactNode
+export declare function JumpIconButton(props: JumpPolymorphicButtonAttributes & { as?: ElementTag; variant?: 'primary' | 'secondary' | 'tertiary' | 'borderless'; status?: 'regular' | 'alarm'; alternateHover?: boolean; elevated?: boolean }): ReactNode
+export declare function JumpLinkButton(props: AnchorHTMLAttributes<HTMLAnchorElement> & { href: string; variant?: 'primary' | 'secondary' | 'tertiary' | 'borderless'; status?: 'regular' | 'alarm'; leadingIcon?: ReactNode; trailingIcon?: ReactNode }): ReactNode
+export declare const JumpInput: import('react').ForwardRefExoticComponent<InputHTMLAttributes<HTMLInputElement> & { status?: JumpInputStatus } & import('react').RefAttributes<HTMLInputElement>>
+export declare function JumpTextarea(props: TextareaHTMLAttributes<HTMLTextAreaElement> & { status?: JumpInputStatus }): ReactNode
+export declare function JumpBaseInput(props: { label?: string; hint?: string; children: ReactNode; className?: string; 'data-testid'?: string; labelTestId?: string; leading?: ReactNode; trailing?: ReactNode; status?: JumpInputStatus; error?: boolean; hideClearIcon?: boolean; showCharCount?: boolean; onClear?: () => void; slots?: JumpBaseInputSlots }): ReactNode
+export declare function JumpField(props: { label?: string; hint?: string; children: ReactNode; className?: string; 'data-testid'?: string; labelTestId?: string; leading?: ReactNode; trailing?: ReactNode; status?: JumpInputStatus; error?: boolean; hideClearIcon?: boolean; showCharCount?: boolean; onClear?: () => void; slots?: JumpBaseInputSlots }): ReactNode
+export declare function JumpChoice(props: ButtonHTMLAttributes<HTMLButtonElement> & { selected?: boolean; title: string; description?: string; className?: string }): ReactNode
+export declare function JumpNotice(props: { tone?: 'info' | 'success' | 'warning' | 'danger'; title?: string; children: ReactNode; className?: string }): ReactNode
+export declare function JumpTabs<T extends string>(props: { items: Array<{ key: T; label: string }>; value: T; onChange: (value: T) => void; className?: string }): ReactNode
+export declare function JumpModal(props: { children: ReactNode }): ReactNode

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@mario_hahn/jumpy-ui",
+  "version": "0.5.0",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "prebuild": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\"",
+    "build": "esbuild index.js theme.js utils.js jumpy-theme-inventory.js --outdir=dist --format=esm --splitting --jsx=automatic --loader:.js=jsx --bundle --external:react --external:react/jsx-runtime --external:@floating-ui/react",
+    "prepack": "npm run build"
+  },
+  "files": [
+    "dist",
+    "index.d.ts",
+    "tokens",
+    "!tokens/ios/.build",
+    "!tokens/ios/.build/**",
+    "theme.d.ts"
+  ],
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./theme": {
+      "types": "./theme.d.ts",
+      "default": "./dist/theme.js"
+    },
+    "./jumpy-theme-inventory": {
+      "default": "./dist/jumpy-theme-inventory.js"
+    },
+    "./tokens/*": {
+      "default": "./tokens/*"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mariohahn/jumpy-ui.git"
+  },
+  "dependencies": {
+    "@floating-ui/react": "^0.27.20"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.2"
+  }
+}

package/theme.d.ts

@@ -0,0 +1,47 @@
+import type { ReactNode } from 'react'
+
+export type JumpyTheme = {
+  spacing?: Record<string, number>
+  radius?: Record<string, number>
+  sizing?: Record<string, number>
+  opacity?: Record<string, number>
+  color?: Record<string, string>
+  actions?: Record<string, unknown>
+  card?: Record<string, unknown>
+  listItem?: Record<string, unknown>
+  sideMenuItem?: Record<string, unknown>
+  selectors?: Record<string, unknown>
+  shadow?: Record<string, string>
+  borderWidth?: Record<string, number>
+  animation?: Record<string, string | number>
+  fontFamily?: Record<string, unknown>
+  typography?: Record<string, string>
+}
+
+export declare const JumpySpacing: Record<string, string>
+export declare const JumpySize: Record<string, string>
+export declare const JumpyRadius: Record<string, string>
+export declare const JumpyOpacity: Record<string, string>
+export declare const JumpyBorderWidth: Record<string, string>
+export declare const JumpyAnimation: Record<string, string>
+export declare const JumpyAnimationDelay: Record<string, string>
+export declare const JumpyAnimationDuration: Record<string, string>
+export declare const JumpyShadowStyle: Record<string, string>
+export declare const JumpyTextStyle: Record<string, string>
+export declare const defaultJumpyTheme: Required<JumpyTheme>
+export declare const jumpyThemePresets: Record<string, JumpyTheme>
+export declare function createJumpyTheme(theme?: JumpyTheme): Required<JumpyTheme>
+export declare function createJumpyThemeFromPreset(presetName?: string, overrides?: JumpyTheme): Required<JumpyTheme>
+export declare function spacingValue(theme: Required<JumpyTheme>, token: string): number
+export declare function sizeValue(theme: Required<JumpyTheme>, token: string): number
+export declare function radiusValue(theme: Required<JumpyTheme>, token: string): number
+export declare function opacityValue(theme: Required<JumpyTheme>, token: string): number
+export declare function borderWidthValue(theme: Required<JumpyTheme>, token: string): number
+export declare function animationDelayValue(theme: Required<JumpyTheme>, token: string): number
+export declare function animationDurationValue(theme: Required<JumpyTheme>, token: string): number
+export declare function animationEasingValue(theme: Required<JumpyTheme>, token: string): string | number
+export declare function shadowValue(theme: Required<JumpyTheme>, token: string): string
+export declare function textStyleValue(theme: Required<JumpyTheme>, token: string): Record<string, unknown>
+export declare function themeToCSSVariables(theme?: JumpyTheme): Record<string, string>
+export declare function JumpyThemeProvider(props: { theme?: JumpyTheme; children: ReactNode }): ReactNode
+export declare function useJumpyTheme(): Required<JumpyTheme>

package/tokens/android/build.gradle.kts

@@ -0,0 +1,4 @@
+plugins {
+    id("com.android.library") version "8.7.3" apply false
+    id("org.jetbrains.kotlin.android") version "2.1.0" apply false
+}

package/tokens/android/settings.gradle.kts

@@ -0,0 +1,4 @@
+pluginManagement { repositories { google(); mavenCentral(); gradlePluginPortal() } }
+dependencyResolutionManagement { repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS); repositories { google(); mavenCentral() } }
+rootProject.name = "JumpyTokens"
+include(":tokens")

package/tokens/android/tokens/build.gradle.kts

@@ -0,0 +1,13 @@
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "com.mariohahn.jumpy.tokens"
+    compileSdk = 35
+
+    defaultConfig {
+        minSdk = 23
+    }
+}