@punkbit/cui 0.0.247-rc.2

package/dist/components/Panel/Panel.d.ts

@@ -0,0 +1,38 @@
+import { CursorOptions, Orientation } from '..';
+import { HTMLAttributes } from 'react';
+export type PanelPadding = "none" | "xs" | "sm" | "md" | "lg" | "xl";
+export type PanelColor = "default" | "muted" | "transparent";
+export type PanelRadii = "none" | "sm" | "md" | "lg";
+type AlignItemsOption = "start" | "center" | "end";
+export interface PanelProps extends HTMLAttributes<HTMLDivElement> {
+    /** Alignment of items along the cross axis */
+    alignItems?: AlignItemsOption;
+    /** The content to display inside the panel */
+    children?: React.ReactNode;
+    /** The background color variant of the panel */
+    color?: PanelColor;
+    /** The cursor style when hovering over the panel */
+    cursor?: CursorOptions;
+    /** Whether the panel should fill the full height of its container */
+    fillHeight?: boolean;
+    /** Whether the panel should fill the full width of its container */
+    fillWidth?: boolean;
+    /** The gap between child elements */
+    gap?: PanelPadding;
+    /** Whether to show a border around the panel */
+    hasBorder?: boolean;
+    /** Whether to show a shadow on the panel */
+    hasShadow?: boolean;
+    /** Fixed height of the panel */
+    height?: string;
+    /** The orientation of content flow - horizontal or vertical */
+    orientation?: Orientation;
+    /** The padding inside the panel */
+    padding?: PanelPadding;
+    /** The border radius of the panel corners */
+    radii?: PanelRadii;
+    /** Fixed width of the panel */
+    width?: string;
+}
+export declare const Panel: ({ alignItems, children, color, cursor, fillHeight, fillWidth, gap, hasBorder, hasShadow, height, orientation, padding, radii, width, ...props }: PanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Popover/Popover.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+import * as RadixPopover from "@radix-ui/react-popover";
+export declare const Popover: {
+    ({ children, ...props }: RadixPopover.PopoverProps): import("react/jsx-runtime").JSX.Element;
+    Trigger: {
+        ({ anchor, children, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        ({ children, showArrow, showClose, forceMount, container, ...props }: PopoverContentProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+interface TriggerProps extends RadixPopover.PopoverTriggerProps {
+    anchor?: ReactNode;
+}
+interface PopoverContentProps extends RadixPopover.PopoverContentProps {
+    /** Whether to show an arrow pointing to the trigger element */
+    showArrow?: boolean;
+    /** Whether to show a close button in the popover */
+    showClose?: boolean;
+    /** Forces the popover to mount in the DOM even when closed */
+    forceMount?: true;
+    /** Custom container element for the popover portal */
+    container?: HTMLElement | null;
+}
+export {};

package/dist/components/ProgressBar/ProgressBar.d.ts

@@ -0,0 +1,40 @@
+import { HTMLAttributes, ReactNode } from 'react';
+interface CommonProgressBarProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The current progress value (0-100) */
+    progress: number;
+    /** Optional label to display */
+    label?: ReactNode;
+    /** Optional error message to display */
+    error?: ReactNode;
+    /** The orientation of the progress bar - horizontal fills width, vertical fills height */
+    orientation?: "vertical" | "horizontal";
+    /** The direction of progress fill - start fills from left/top, end fills from right/bottom */
+    dir?: "start" | "end";
+}
+interface DefaultProgressBar extends CommonProgressBarProps {
+    /** The type of progress bar - "default" shows text and close button */
+    type?: "default";
+    /** Message to display when progress reaches 100% */
+    successMessage?: ReactNode;
+}
+interface SmallProgressBar extends CommonProgressBarProps {
+    /** The type of progress bar - "small" shows only the progress indicator */
+    type: "small";
+    successMessage?: never;
+    dismissable?: never;
+    onCancel?: never;
+}
+interface DismissableProgressBar {
+    /** When true, shows a close button to cancel the progress */
+    dismissable: true;
+    /** Callback function when the close button is clicked */
+    onCancel: () => void;
+}
+interface NonDismissableProgressBar {
+    /** When false or undefined, the close button is hidden */
+    dismissable?: false;
+    onCancel?: never;
+}
+export type ProgressBarProps = (DefaultProgressBar & (DismissableProgressBar | NonDismissableProgressBar)) | SmallProgressBar;
+export declare const ProgressBar: ({ progress, type, dismissable, onCancel, successMessage, orientation, dir, ...props }: ProgressBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/RadioGroup/RadioGroup.d.ts

@@ -0,0 +1,29 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import * as RadixRadioGroup from "@radix-ui/react-radio-group";
+export interface RadioGroupProps extends Omit<RadixRadioGroup.RadioGroupProps, "dir"> {
+    /** Whether to display radio items inline (horizontally) */
+    inline?: boolean;
+    /** The orientation of the label relative to the radio group */
+    orientation?: "vertical" | "horizontal";
+    /** The direction/position of the label - start places label before, end places label after */
+    dir?: "start" | "end";
+    /** Text direction for radio items - ltr or rtl */
+    itemDir?: "rtl" | "ltr";
+    /** The label text displayed next to the radio group */
+    label?: ReactNode;
+    /** Error message to display below the radio group */
+    error?: ReactNode;
+}
+export declare const RadioGroup: {
+    ({ children, inline, orientation, dir, error, itemDir, label, disabled, id, ...props }: RadioGroupProps): import("react/jsx-runtime").JSX.Element;
+    Item: {
+        ({ id, label, value, disabled, required, ...props }: RadioGroupItemProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+interface RadioGroupInputProps extends RadixRadioGroup.RadioGroupItemProps {
+    /** The label text displayed next to the radio item */
+    label?: ReactNode;
+}
+export type RadioGroupItemProps = RadioGroupInputProps & HTMLAttributes<HTMLDivElement>;
+export {};

package/dist/components/Select/CheckboxMultiSelect.d.ts

@@ -0,0 +1,10 @@
+import { MultiSelectProps } from '..';
+export interface CheckboxMultiSelectProps extends MultiSelectProps {
+    selectLabel?: string;
+}
+export declare const CheckboxMultiSelect: {
+    ({ value: valueProp, defaultValue, onSelect: onSelectProp, options, children, onOpenChange: onOpenChangeProp, selectLabel, ...props }: CheckboxMultiSelectProps): import("react/jsx-runtime").JSX.Element;
+    Group: import('react').ForwardRefExoticComponent<import('./common/types').SelectGroupProps & import('react').RefAttributes<HTMLDivElement>>;
+    Item: import('react').ForwardRefExoticComponent<import('./common/InternalSelect').MultiSelectCheckboxItemProps & import('react').RefAttributes<HTMLDivElement>>;
+    ItemDescription: import('react').ForwardRefExoticComponent<import('..').TextProps<"p"> & import('react').RefAttributes<HTMLDivElement>>;
+};

package/dist/components/Select/MultiSelect.d.ts

@@ -0,0 +1,15 @@
+import { KeyboardEvent, MouseEvent } from 'react';
+import { SelectContainerProps, SelectionType } from './common/types';
+export interface MultiSelectProps extends Omit<SelectContainerProps, "onChange" | "value" | "open" | "onOpenChange" | "onSelect"> {
+    defaultValue?: Array<string>;
+    onSelect?: (value: Array<string>, type?: SelectionType, evt?: KeyboardEvent<HTMLElement> | MouseEvent<HTMLElement>) => void;
+    value?: Array<string>;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare const MultiSelect: {
+    ({ value: valueProp, defaultValue, onSelect: onSelectProp, options, children, onOpenChange: onOpenChangeProp, ...props }: MultiSelectProps): import("react/jsx-runtime").JSX.Element;
+    Group: import('react').ForwardRefExoticComponent<import('./common/types').SelectGroupProps & import('react').RefAttributes<HTMLDivElement>>;
+    Item: import('react').ForwardRefExoticComponent<import('./common/types').SelectItemProps & import('react').RefAttributes<HTMLDivElement>>;
+    ItemDescription: import('react').ForwardRefExoticComponent<import('..').TextProps<"p"> & import('react').RefAttributes<HTMLDivElement>>;
+};

package/dist/components/Select/MultiSelectValue.d.ts

@@ -0,0 +1,11 @@
+import { SelectItemProps } from './common/types';
+interface MultiSelectValueProps {
+    selectedValues: Array<string>;
+    valueNode: Map<string, SelectItemProps>;
+    onChange: (selectedValues: Array<string>) => void;
+    onSelect: (selectedValue: string) => void;
+    sortable: boolean;
+    disabled: boolean;
+}
+export declare const MultiSelectValue: ({ selectedValues, valueNode, onChange, sortable, onSelect, disabled, }: MultiSelectValueProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/Select/SingleSelect.d.ts

@@ -0,0 +1,17 @@
+import { KeyboardEvent, MouseEvent } from 'react';
+import { SelectContainerProps, SelectionType } from './common/types';
+export interface SelectProps extends Omit<SelectContainerProps, "onChange" | "value" | "sortable" | "open" | "onOpenChange" | "onSelect"> {
+    defaultValue?: string;
+    onSelect?: (value: string, type?: SelectionType, evt?: KeyboardEvent<HTMLElement> | MouseEvent<HTMLElement>) => void;
+    value?: string;
+    placeholder?: string;
+    onOpenChange?: (open: boolean) => void;
+    useFullWidthItems?: boolean;
+    itemCharacterLimit?: string;
+}
+export declare const Select: {
+    ({ value: valueProp, defaultValue, onSelect: onSelectProp, options, children, onOpenChange: onOpenChangeProp, ...props }: SelectProps): import("react/jsx-runtime").JSX.Element;
+    Group: import('react').ForwardRefExoticComponent<import('./common/types').SelectGroupProps & import('react').RefAttributes<HTMLDivElement>>;
+    Item: import('react').ForwardRefExoticComponent<import('./common/types').SelectItemProps & import('react').RefAttributes<HTMLDivElement>>;
+    ItemDescription: import('react').ForwardRefExoticComponent<import('..').TextProps<"p"> & import('react').RefAttributes<HTMLDivElement>>;
+};

package/dist/components/Select/SingleSelectValue.d.ts

@@ -0,0 +1,6 @@
+import { SelectItemProps } from './common/types';
+declare const SingleSelectValue: ({ valueNode, value, }: {
+    valueNode?: SelectItemProps;
+    value: string;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default SingleSelectValue;

package/dist/components/Select/common/InternalSelect.d.ts

@@ -0,0 +1,14 @@
+import { SelectContainerProps, SelectGroupProps, SelectItemProps } from './types';
+import { CheckboxVariants, TextProps } from '../..';
+export interface NoAvailableOptionsFactoryProps {
+    search: string;
+    close: () => void;
+}
+export declare const InternalSelect: ({ label, children, orientation, dir, disabled, id, error, value: selectedValues, onChange, onSelect, open, onOpenChange, name, form, allowCreateOption, customText, options, sortable, placeholder, maxHeight, multiple, checkbox, selectLabel, showSearch, container, useFullWidthItems, itemCharacterLimit, noAvailableOptions, ...props }: SelectContainerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SelectGroup: import('react').ForwardRefExoticComponent<SelectGroupProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const SelectItem: import('react').ForwardRefExoticComponent<SelectItemProps & import('react').RefAttributes<HTMLDivElement>>;
+export type MultiSelectCheckboxItemProps = SelectItemProps & {
+    variant?: CheckboxVariants;
+};
+export declare const MultiSelectCheckboxItem: import('react').ForwardRefExoticComponent<MultiSelectCheckboxItemProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const SelectItemDescription: import('react').ForwardRefExoticComponent<TextProps<"p"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/Select/common/OptionContext.d.ts

@@ -0,0 +1,13 @@
+import { KeyboardEvent, MouseEvent } from 'react';
+import { SelectionType } from './types';
+type OptionContextProps = {
+    search: string;
+    highlighted?: string;
+    updateHighlighted: (value: string) => void;
+    isHidden: (value?: string) => boolean;
+    selectedValues: Array<string>;
+    onSelect: (value: string, type?: SelectionType, evt?: KeyboardEvent<HTMLElement> | MouseEvent<HTMLElement>) => void;
+    showCheck?: boolean;
+};
+export declare const OptionContext: import('react').Context<OptionContextProps>;
+export {};

package/dist/components/Select/common/SelectStyled.d.ts

@@ -0,0 +1,30 @@
+export declare const SelectPopoverRoot: import('styled-components').StyledComponent<import('react').FC<import('@radix-ui/react-popover').PopoverProps>, import('styled-components').DefaultTheme, {}, never>;
+export declare const SelectValue: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {}, never>;
+export declare const StyledSelectTrigger: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<import('@radix-ui/react-popover').PopoverTriggerProps & import('react').RefAttributes<HTMLButtonElement>>, import('styled-components').DefaultTheme, {
+    $error: boolean;
+}, never>;
+export declare const SelectPopoverContent: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<import('@radix-ui/react-popover').PopoverContentProps & import('react').RefAttributes<HTMLDivElement>>, import('styled-components').DefaultTheme, {
+    $useFullWidthItems: boolean;
+    $itemCharacterLimit?: string;
+}, never>;
+export declare const SearchBarContainer: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {
+    $showSearch: boolean;
+}, never>;
+export declare const SearchBar: import('styled-components').StyledComponent<"input", import('styled-components').DefaultTheme, {
+    $showSearch: boolean;
+}, never>;
+export declare const SearchClose: import('styled-components').StyledComponent<"button", import('styled-components').DefaultTheme, {
+    $showClose: boolean;
+}, never>;
+export declare const SelectList: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {}, never>;
+export declare const SelectListContent: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {
+    $maxHeight?: string;
+}, never>;
+export declare const HiddenSelectElement: import('styled-components').StyledComponent<"select", import('styled-components').DefaultTheme, {}, never>;
+export declare const SelectGroupContainer: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {}, never>;
+export declare const SelectGroupName: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {}, never>;
+export declare const SelectGroupContent: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {}, never>;
+export declare const SelectNoDataContainer: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {
+    $clickable: boolean;
+}, never>;
+export declare const SelectItemDescriptionText: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {}, never>;

package/dist/components/Select/common/types.d.ts

@@ -0,0 +1,92 @@
+import { HTMLAttributes, KeyboardEvent, MouseEvent, ReactNode } from 'react';
+import { HorizontalDirection, IconName } from '../..';
+import { PopoverProps } from '@radix-ui/react-popover';
+import { NoAvailableOptionsFactoryProps } from './InternalSelect';
+declare type DivProps = HTMLAttributes<HTMLDivElement>;
+interface SelectItemComponentProps extends Omit<DivProps, "disabled" | "onSelect" | "value" | "children"> {
+    separator?: boolean;
+    disabled?: boolean;
+    onSelect?: (value: string, type?: SelectionType, evt?: KeyboardEvent<HTMLElement> | MouseEvent<HTMLElement>) => void;
+    value: string;
+    icon?: IconName;
+    iconDir?: HorizontalDirection;
+}
+type SelectItemChildren = {
+    children: ReactNode;
+    label?: never;
+    description?: never;
+};
+type SelectItemLabel = {
+    children?: never;
+    label: ReactNode;
+    description?: ReactNode;
+};
+export type SelectItemProps = SelectItemComponentProps & (SelectItemChildren | SelectItemLabel);
+export interface SelectGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, "heading"> {
+    heading: ReactNode;
+    value?: never;
+    onSelect?: never;
+}
+export interface SelectOptionItem extends Omit<SelectItemProps, "children" | "label" | "description"> {
+    heading?: never;
+    label: ReactNode;
+    description?: ReactNode;
+    [key: `data-${string}`]: string;
+}
+export interface SelectGroupOptionItem extends Omit<SelectGroupProps, "children" | "label" | "description"> {
+    options: Array<SelectOptionItem>;
+    label?: never;
+    [key: `data-${string}`]: string;
+}
+export type SelectOptionListItem = SelectGroupOptionItem | SelectOptionItem;
+type SelectOptionType = {
+    options: Array<SelectOptionListItem>;
+    children?: never;
+};
+type SelectChildrenType = {
+    children: ReactNode;
+    options?: never;
+};
+export type SelectionType = "custom" | "default";
+interface InternalSelectProps extends PopoverProps, Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "dir" | "onSelect" | "children"> {
+    onChange: (selectedValues: Array<string>) => void;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (value: string, type?: SelectionType, evt?: KeyboardEvent<HTMLElement> | MouseEvent<HTMLElement>) => void;
+    open: boolean;
+    value: Array<string>;
+    allowCreateOption?: boolean;
+    checkbox?: boolean;
+    container?: HTMLElement;
+    customText?: string;
+    dir?: "start" | "end";
+    disabled?: boolean;
+    error?: ReactNode;
+    form?: string;
+    itemCharacterLimit?: string;
+    label?: ReactNode;
+    maxHeight?: string;
+    multiple?: boolean;
+    name?: string;
+    /**
+     * Controls rendering when no options are available.
+     * - false: renders nothing
+     * - true: renders default message 'No Options found' with search term if present
+     * - ({ search: string, onClose: () => void }) => ReactNode: renders the returned node allowing dynamic content based on current search string
+     */
+    noAvailableOptions?: boolean | ((props: NoAvailableOptionsFactoryProps) => ReactNode);
+    orientation?: "horizontal" | "vertical";
+    placeholder?: string;
+    selectLabel?: string;
+    showSearch?: boolean;
+    sortable?: boolean;
+    useFullWidthItems?: boolean;
+}
+export type SelectOptionProp = SelectOptionType | SelectChildrenType;
+export type SelectContainerProps = SelectOptionProp & InternalSelectProps;
+export type SelectItemObject = {
+    disabled?: boolean;
+    value: string;
+    title: string;
+    heading?: string;
+};
+export {};

package/dist/components/Select/common/useOption.d.ts

@@ -0,0 +1,10 @@
+export declare const useOption: () => {
+    search: string;
+    highlighted?: string;
+    updateHighlighted: (value: string) => void;
+    isHidden: (value?: string) => boolean;
+    selectedValues: Array<string>;
+    onSelect: (value: string, type?: import('./types').SelectionType, evt?: import('react').KeyboardEvent<HTMLElement> | import('react').MouseEvent<HTMLElement>) => void;
+    showCheck?: boolean;
+};
+export declare const useSearch: () => string;

package/dist/components/Select/selectOptions.d.ts

@@ -0,0 +1,3 @@
+import { SelectOptionListItem } from './common/types';
+export declare const selectOptions: Array<SelectOptionListItem>;
+export declare const selectOptionsLong: Array<SelectOptionListItem>;

package/dist/components/Separator/Separator.d.ts

@@ -0,0 +1,7 @@
+import * as RadixSeparator from "@radix-ui/react-separator";
+export interface SeparatorProps extends RadixSeparator.SeparatorProps {
+    /** The size/spacing of the separator */
+    size: "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+}
+declare const Separator: ({ orientation, ...props }: SeparatorProps) => import("react/jsx-runtime").JSX.Element;
+export default Separator;

package/dist/components/SidebarCollapsibleItem/SidebarCollapsibleItem.d.ts

@@ -0,0 +1,26 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { HorizontalDirection, IconName } from '..';
+export interface SidebarCollapsibleItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** The label content to display */
+    label: ReactNode;
+    /** The content to display when expanded */
+    children: ReactNode;
+    /** Whether the item is expanded */
+    open?: boolean;
+    /** Callback when the open state changes */
+    onOpenChange?: (value: boolean) => void;
+    /** The direction of the icon relative to the label */
+    iconDir?: HorizontalDirection;
+    /** Icon to display before the label */
+    icon?: IconName;
+    /** The direction of the collapse indicator */
+    indicatorDir?: HorizontalDirection;
+    /** Whether the item is currently selected */
+    selected?: boolean;
+    /** Nesting level for indentation */
+    level?: number;
+    /** The sidebar style type */
+    type?: "main" | "sqlSidebar";
+}
+declare const SidebarCollapsibleItem: import('react').ForwardRefExoticComponent<SidebarCollapsibleItemProps & import('react').RefAttributes<HTMLDivElement>>;
+export { SidebarCollapsibleItem };

package/dist/components/SidebarCollapsibleTitle/SidebarCollapsibleTitle.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { HorizontalDirection, IconName } from '..';
+export interface SidebarCollapsibleTitleProps extends React.HTMLAttributes<HTMLButtonElement> {
+    /** The label content to display */
+    label: ReactNode;
+    /** The content to display when expanded */
+    children: React.ReactNode;
+    /** Whether the title section is expanded */
+    open?: boolean;
+    /** Callback when the open state changes */
+    onOpenChange?: (value: boolean) => void;
+    /** The direction of the icon relative to the label */
+    iconDir?: HorizontalDirection;
+    /** Icon to display before the label */
+    icon?: IconName;
+    /** Whether the title is currently selected */
+    selected?: boolean;
+    /** The sidebar style type */
+    type?: "main" | "sqlSidebar";
+}
+export declare const SidebarCollapsibleTitle: ({ label, children, open, onOpenChange, iconDir, icon, selected, type, ...props }: SidebarCollapsibleTitleProps) => import("react/jsx-runtime").JSX.Element | undefined;

package/dist/components/SidebarNavigationItem/SidebarNavigationItem.d.ts

@@ -0,0 +1,25 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { HorizontalDirection, IconName } from '..';
+export interface SidebarNavigationItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** The label content to display */
+    label: ReactNode;
+    /** Whether the item is currently selected */
+    selected?: boolean;
+    /** Whether the item is disabled */
+    disabled?: boolean;
+    /** Nesting level for indentation */
+    level?: number;
+    /** Icon to display before the label */
+    icon?: IconName;
+    /** The direction of the icon relative to the label */
+    iconDir?: HorizontalDirection;
+    /** The sidebar style type */
+    type?: "main" | "sqlSidebar";
+}
+declare const SidebarNavigationItem: import('react').ForwardRefExoticComponent<SidebarNavigationItemProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const SidebarItemWrapper: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {
+    $collapsible?: boolean;
+    $level: number;
+    $type: "main" | "sqlSidebar";
+}, never>;
+export { SidebarNavigationItem };

package/dist/components/SidebarNavigationTitle/SidebarNavigationTitle.d.ts

@@ -0,0 +1,19 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { HorizontalDirection, IconName } from '..';
+export interface SidebarNavigationTitleProps extends HTMLAttributes<HTMLButtonElement> {
+    /** The label content to display */
+    label: ReactNode;
+    /** Whether the title is currently selected */
+    selected?: boolean;
+    /** Icon to display before the label */
+    icon?: IconName;
+    /** The direction of the icon relative to the label */
+    iconDir?: HorizontalDirection;
+    /** The sidebar style type */
+    type?: "main" | "sqlSidebar";
+}
+export declare const SidebarNavigationTitle: ({ label, icon, iconDir, selected, type, ...props }: SidebarNavigationTitleProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SidebarTitleWrapper: import('styled-components').StyledComponent<"button", import('styled-components').DefaultTheme, {
+    $collapsible?: boolean;
+    $type: "main" | "sqlSidebar";
+}, never>;

package/dist/components/Spacer/Spacer.d.ts

@@ -0,0 +1,6 @@
+export type SizeType = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+export interface SpacerProps {
+    /** The size of the spacer */
+    size?: SizeType;
+}
+export declare const Spacer: ({ size }: SpacerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/SplitButton/SplitButton.d.ts

@@ -0,0 +1,41 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { DropdownMenuProps } from '@radix-ui/react-dropdown-menu';
+import { IconName, HorizontalDirection } from '..';
+type ButtonType = "primary" | "secondary";
+type MenuItem = {
+    icon?: IconName;
+    iconDir?: HorizontalDirection;
+    label: ReactNode;
+    type?: "item";
+    items?: never;
+} & Omit<HTMLAttributes<HTMLDivElement>, "onSelect">;
+type MenuGroup = {
+    icon?: never;
+    iconDir?: never;
+    label?: never;
+    type: "group";
+    items: Array<MenuItem | SubMenu>;
+};
+type SubMenu = Omit<MenuItem, "type" | "items"> & {
+    items: Array<MenuGroup | MenuItem>;
+    type: "sub-menu";
+};
+export type Menu = SubMenu | MenuGroup | MenuItem;
+export interface SplitButtonProps extends DropdownMenuProps, Omit<HTMLAttributes<HTMLButtonElement>, "dir"> {
+    /** The visual style variant of the button */
+    type?: ButtonType;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /** Whether the button should fill the full width of its container */
+    fillWidth?: boolean;
+    /** The menu items to display in the dropdown */
+    menu: Array<Menu>;
+    /** Which side of the button to show the dropdown */
+    side?: "top" | "bottom";
+    /** Optional icon to display in the main button */
+    icon?: IconName;
+    /** The direction of the icon relative to the label */
+    iconDir?: HorizontalDirection;
+}
+export declare const SplitButton: ({ type, disabled, menu, dir, open, defaultOpen, onOpenChange, modal, side, fillWidth, children, icon, iconDir, ...props }: SplitButtonProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Switch/Switch.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import * as RadixSwitch from "@radix-ui/react-switch";
+interface RootProps {
+    /** Whether the switch is checked/on */
+    checked: boolean;
+    /** Whether the switch is disabled */
+    disabled?: boolean;
+    /** The orientation of the label relative to the switch */
+    orientation?: "vertical" | "horizontal";
+    /** The direction/position of the label - start places label before, end places label after */
+    dir?: "start" | "end";
+    /** The label text displayed next to the switch */
+    label?: ReactNode;
+}
+export declare const Switch: import('react').ForwardRefExoticComponent<RootProps & Omit<RadixSwitch.SwitchProps, "dir"> & import('react').RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/Table/Table.d.ts

@@ -0,0 +1,53 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { HorizontalDirection } from '..';
+type SortDir = "asc" | "desc";
+type SortFn = (sortDir: SortDir, header: TableHeaderType, index: number) => void;
+type TableSize = "sm" | "md";
+export interface TableHeaderType extends HTMLAttributes<HTMLTableCellElement> {
+    label: ReactNode;
+    isSortable?: boolean;
+    sortDir?: SortDir;
+    sortPosition?: HorizontalDirection;
+    width?: string;
+}
+interface TableCellType extends HTMLAttributes<HTMLTableCellElement> {
+    label: ReactNode;
+}
+export interface TableRowType extends Omit<HTMLAttributes<HTMLTableRowElement>, "onSelect" | "id"> {
+    id: string | number;
+    items: Array<TableCellType>;
+    isDisabled?: boolean;
+    isDeleted?: boolean;
+    isActive?: boolean;
+    /** only works with <Table isSelectable={true} /> */
+    isIndeterminate?: boolean;
+}
+interface CommonTableProps extends Omit<HTMLAttributes<HTMLTableElement>, "children" | "onSelect"> {
+    headers: Array<TableHeaderType>;
+    rows: Array<TableRowType>;
+    onDelete?: (item: TableRowType, index: number) => void;
+    onEdit?: (item: TableRowType, index: number) => void;
+    onSort?: SortFn;
+    loading?: boolean;
+    noDataMessage?: ReactNode;
+    size?: TableSize;
+    showHeader?: boolean;
+    rowHeight?: string;
+}
+type SelectReturnValue = {
+    index: number;
+    item: TableRowType;
+};
+interface SelectionType {
+    isSelectable?: boolean;
+    selectedIds?: Array<number | string>;
+    onSelect?: (selectedValues: Array<SelectReturnValue>) => void;
+}
+interface NoSelectionType {
+    isSelectable?: never;
+    selectedIds?: never;
+    onSelect?: never;
+}
+export type TableProps = CommonTableProps & (SelectionType | NoSelectionType);
+declare const Table: import('react').ForwardRefExoticComponent<TableProps & import('react').RefAttributes<HTMLTableElement>>;
+export { Table };

package/dist/components/Tabs/Tabs.d.ts

@@ -0,0 +1,18 @@
+import * as RadixTabs from "@radix-ui/react-tabs";
+export interface TabsProps extends RadixTabs.TabsProps {
+    /** Accessible label for the tabs component */
+    ariaLabel?: string;
+}
+declare const Tabs: {
+    ({ defaultValue, children, ariaLabel, onValueChange, ...delegated }: TabsProps): import("react/jsx-runtime").JSX.Element;
+    TriggersList: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<RadixTabs.TabsListProps & import('react').RefAttributes<HTMLDivElement>>, import('styled-components').DefaultTheme, {}, never>;
+    Trigger: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<RadixTabs.TabsTriggerProps & import('react').RefAttributes<HTMLButtonElement>>, import('styled-components').DefaultTheme, {}, never>;
+    Content: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<RadixTabs.TabsContentProps & import('react').RefAttributes<HTMLDivElement>>, import('styled-components').DefaultTheme, {}, never>;
+};
+declare const FullWidthTabs: import('styled-components').StyledComponent<{
+    ({ defaultValue, children, ariaLabel, onValueChange, ...delegated }: TabsProps): import("react/jsx-runtime").JSX.Element;
+    TriggersList: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<RadixTabs.TabsListProps & import('react').RefAttributes<HTMLDivElement>>, import('styled-components').DefaultTheme, {}, never>;
+    Trigger: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<RadixTabs.TabsTriggerProps & import('react').RefAttributes<HTMLButtonElement>>, import('styled-components').DefaultTheme, {}, never>;
+    Content: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<RadixTabs.TabsContentProps & import('react').RefAttributes<HTMLDivElement>>, import('styled-components').DefaultTheme, {}, never>;
+}, import('styled-components').DefaultTheme, {}, never>;
+export { Tabs, FullWidthTabs };