@salt-ds/lab 1.0.0-alpha.0

package/dist-types/cascading-menu/CascadingMenuList.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="react" />
+import { ListProps } from "../list-deprecated";
+import { MenuItemProps } from "./CascadingMenuItem";
+import { screenBounds } from "./internal/menuPositioning";
+import { menuState } from "./internal/stateUtils";
+import { refsManager } from "./internal/useRefsManager";
+import { UseFloatingUIProps } from "../popper";
+import "./CascadingMenuList.css";
+export interface CascadingMenuListProps {
+    className?: string;
+    data: menuState;
+    delay?: number;
+    disableMouseOutInteractions?: boolean;
+    dispatch: (action: any) => void;
+    getBoundingClientRect?: (element: HTMLElement) => DOMRect;
+    getScreenBounds?: () => screenBounds;
+    height?: number;
+    highlightedItemIndex: number | null;
+    isChildMenuOpen: boolean;
+    itemToString: MenuItemProps["itemToString"];
+    isNavigatingWithKeyboard: boolean;
+    isRoot: boolean;
+    maxWidth?: ListProps["maxWidth"];
+    menuId: string;
+    menuTriggerRef: HTMLElement | null;
+    minWidth?: ListProps["minWidth"];
+    onItemClick?: MenuItemProps["onItemClick"];
+    parentElement?: HTMLElement | null;
+    refsManager: refsManager;
+    rootPlacement?: UseFloatingUIProps["placement"];
+    rootPlacementOffset?: string;
+    rowHeight?: number;
+    setIsNavigatingWithKeyboard: (value: boolean) => void;
+    tooltipEnterDelay: number;
+    tooltipLeaveDelay: number;
+}
+export declare const CascadingMenuList: import("react").ForwardRefExoticComponent<CascadingMenuListProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/cascading-menu/CascadingMenuProps.d.ts

@@ -0,0 +1,124 @@
+import { IconProps } from "@salt-ds/icons";
+import { ComponentType, HTMLAttributes, ReactNode, MouseEvent, KeyboardEvent } from "react";
+import { ItemToStringFunction } from "../list-deprecated";
+import { CascadingMenuListProps } from "./CascadingMenuList";
+import { UseFloatingUIProps } from "../popper";
+export interface ScreenBounds {
+    clientHeight: number;
+    clientWidth: number;
+}
+export interface MenuDescriptor {
+    id?: string;
+    menuItems?: MenuDescriptor[];
+    title?: string;
+    divider?: boolean;
+    disabled?: boolean;
+    tooltip?: string;
+    icon?: ComponentType<IconProps>;
+}
+export interface CascadingMenuProps extends HTMLAttributes<HTMLElement> {
+    /**
+     * Cascading Menu reference element.
+     * Needs to be able to hold a ref. If you are passing a custom component remember to spread the props
+     * over your component.
+     * If you want pass a ref instead and have control over opening/closing the cascading cascading menu,
+     * please see {menuTriggerRef}
+     */
+    children?: ReactNode;
+    /**
+     * The document the Cascading Menu will use to listen for click away events.
+     * Useful when rendering the Cascading Menu in other windows.
+     */
+    containingDocument?: Document;
+    /**
+     * Delay in ms before opening and closing a submenu on mouse hover or mouse out
+     */
+    delay?: number;
+    /**
+     * By default Cascading Menu will close when clicking outside the menus.
+     * Use this prop to disable this feature.
+     */
+    disableClickAway?: boolean;
+    /**
+     * By default Cascading Menu closes a submenu when mouse out of the parent menu.
+     * Use this prop to disable this feature.
+     */
+    disableMouseOutInteractions?: boolean;
+    /**
+     * Used by Cascading Menu to get the clientWidth and clientHeight of the virtual viewport.
+     * Useful when rendering the Cascading Menu in other windows.
+     */
+    getScreenBounds?: () => ScreenBounds;
+    /**
+     * Height in pixels of the menu
+     */
+    height?: number;
+    /**
+     * The menu placement with regard to its trigger component.
+     */
+    rootPlacement?: UseFloatingUIProps["placement"];
+    /**
+     * The x and y offset coordinates of the root menu. Conforms to Popper spec in format `${x},${y}`
+     */
+    rootPlacementOffset?: string;
+    /**
+     * Uncontrolled property for specifying the initial source of cascading menu items.
+     * Ids have to be unique within the cascading menu
+     */
+    initialSource?: MenuDescriptor;
+    /**
+     * Used to determine the string value for the selected item.
+     */
+    itemToString?: ItemToStringFunction;
+    /**
+     * Maximum menu width  (text longer than the max width will end with ellipsis)
+     * set to "null" to allow the content to take as much space as needed with no truncating. Defaults to 544
+     */
+    maxWidth?: CascadingMenuListProps["maxWidth"];
+    /**
+     * Cascading Menu reference element used to position the cascading menu.
+     * Use with the open controlled prop if not passing the menu trigger as children.
+     * This has to be a native DOM element node,
+     */
+    menuTriggerRef?: HTMLElement;
+    /**
+     * Minimum menu width, if the content is smaller than the minWidth the menu width will be the same as minWidth
+     * otherwise it will increase to the smallest width between content size and maxWidth. Defaults to 200
+     */
+    minWidth?: CascadingMenuListProps["minWidth"];
+    /**
+     * Callback that fires when a menu closes.
+     */
+    onClose?: () => void;
+    /**
+     * Callback that fires a menu item is clicked.
+     * @param {MenuDescriptor} source item clicked
+     * @param {MouseEvent | KeyboardEvent} click event
+     */
+    onItemClick?: (sourceItem: MenuDescriptor, event: MouseEvent | KeyboardEvent) => void;
+    /**
+     * Callback that fires when menu opens.
+     */
+    onOpen?: () => void;
+    /**
+     * Controlled prop to open/close the cascading menu
+     */
+    open?: boolean;
+    /**
+     * Height of a row in the list
+     */
+    rowHeight?: number;
+    /**
+     * Controlled property for specifying the source of cascading menu items.
+     * Ids have to be unique within the cascading menu
+     */
+    source?: MenuDescriptor;
+    /**
+     * The number of milliseconds to wait before showing the tooltip. Defaults to 1500 ms
+     */
+    tooltipEnterDelay?: number;
+    /**
+     * The number of milliseconds to wait before hiding the tooltip. Defaults to 0 ms
+     */
+    tooltipLeaveDelay?: number;
+}

package/dist-types/cascading-menu/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./CascadingMenu";
+export * from "./CascadingMenuProps";

package/dist-types/cascading-menu/internal/CascadingMenuAction.d.ts

@@ -0,0 +1,10 @@
+import { stateChangeCause } from "../stateChangeTypes";
+export declare type menuActionType = "setCurrentInteractedItem" | "resetMenu" | "openMenu" | "closeMenu" | "closeCascadingMenu" | "setFlipped";
+export declare type menuAction = {
+    type: menuActionType;
+    cause: stateChangeCause;
+    flipped?: boolean;
+    highlightedItemIndex?: number;
+    targetId: string;
+};
+export declare const CascadingMenuAction: Record<string, menuActionType>;

package/dist-types/cascading-menu/internal/keydownHandlers.d.ts

@@ -0,0 +1,7 @@
+import { CascadingMenuListProps } from "../CascadingMenuList";
+import { Dispatch, SetStateAction, KeyboardEvent } from "react";
+interface getKeyDownHandlersProps extends CascadingMenuListProps {
+    keyDownHandlersOverride?: Record<string, (event: Event) => void>;
+}
+export declare function getKeyDownHandlers(props: getKeyDownHandlersProps, setIsMenuActive: Dispatch<SetStateAction<boolean>>): (event: KeyboardEvent<HTMLElement>) => void;
+export {};

package/dist-types/cascading-menu/internal/menuPositioning.d.ts

@@ -0,0 +1,7 @@
+export declare type screenBounds = {
+    clientHeight: number;
+    clientWidth: number;
+};
+export declare function getMaxHeight(heightProp: number | undefined, menuMargin?: number | undefined, getScreenBounds?: () => screenBounds): number;
+export declare function getHeight(heightProp: number | undefined, calculatedMenuHeight: number, maxHeight: number): number;
+export declare const defaultGetScreenBounds: () => screenBounds;

package/dist-types/cascading-menu/internal/stateUtils.d.ts

@@ -0,0 +1,19 @@
+import { MenuDescriptor } from "../CascadingMenuProps";
+export declare type menuState = {
+    id: string;
+    flipped?: boolean;
+    highlightedItemIndex?: number;
+    level: number;
+    parentId: string | null;
+    childMenus: {
+        [key: number]: string;
+    };
+    menuItems: MenuDescriptor[];
+};
+export declare type flattenedMenuState = {
+    [key: string]: menuState;
+};
+export declare function deriveFlatStateFromTree(tree: MenuDescriptor, parentId?: string | null, level?: number, generatedId?: string): flattenedMenuState;
+export declare function hasSubMenu(item: MenuDescriptor): boolean;
+export declare function isMenuItem(item: MenuDescriptor): boolean;
+export declare function hasIcon(item: MenuDescriptor): boolean;

package/dist-types/cascading-menu/internal/useClickAway.d.ts

@@ -0,0 +1,3 @@
+declare type clickAwayHook = (nodes: HTMLElement[] | (() => HTMLElement[]) | null, containingDocument: Document, onClickAway: (event: FocusEvent) => void, onClick: (event: MouseEvent) => void, mouseEvent?: keyof DocumentEventMap) => void;
+export declare const useClickAway: clickAwayHook;
+export {};

package/dist-types/cascading-menu/internal/useMenuTriggerHandlers.d.ts

@@ -0,0 +1,15 @@
+import { CascadingMenuProps } from "../CascadingMenuProps";
+import { menuState } from "./stateUtils";
+import { stateItem } from "./useStateReducer";
+import { MouseEvent, KeyboardEvent } from "react";
+interface useMenuTriggerHandlersProps {
+    dispatch: (action: any) => void;
+    children: CascadingMenuProps["children"];
+    setIsNavigatingWithKeyboard: (value: boolean) => void;
+    openCloseMenu: (open: boolean) => void;
+    rootMenuState: stateItem;
+    rootMenuId: string | undefined;
+    menusDataById: Record<string, menuState>;
+}
+export declare function useMenuTriggerHandlers({ dispatch, children, setIsNavigatingWithKeyboard, openCloseMenu, rootMenuState, rootMenuId, menusDataById, }: useMenuTriggerHandlersProps): readonly [(event: MouseEvent<HTMLElement, globalThis.MouseEvent>) => void, (event: KeyboardEvent<HTMLElement>) => void];
+export {};

package/dist-types/cascading-menu/internal/useMountedRef.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+/**
+ * Used to know if the component is mounted or not
+ */
+export declare function useMountedRef(): import("react").MutableRefObject<boolean>;

package/dist-types/cascading-menu/internal/useMouseHandlers.d.ts

@@ -0,0 +1,3 @@
+import { Dispatch, SetStateAction, MouseEvent } from "react";
+import { CascadingMenuListProps } from "../CascadingMenuList";
+export declare function useMouseHandlers(props: CascadingMenuListProps, isMenuActiveState: [boolean, Dispatch<SetStateAction<boolean>>], menuRef: HTMLElement | null): readonly [(highlightedIndex: number) => void, (event: MouseEvent<HTMLElement>) => void];

package/dist-types/cascading-menu/internal/useRefsManager.d.ts

@@ -0,0 +1,6 @@
+export declare type refsManager = {
+    get: (key: string) => HTMLElement | undefined;
+    set: (key: string, ref: HTMLElement) => void;
+    values: () => HTMLElement[];
+};
+export declare function useRefsManager(): refsManager;

package/dist-types/cascading-menu/internal/useStateReducer.d.ts

@@ -0,0 +1,9 @@
+import { flattenedMenuState } from "./stateUtils";
+import { menuAction } from "./CascadingMenuAction";
+export declare type stateItem = {
+    id: string;
+    highlightedItemIndex: number | null;
+};
+declare type state = stateItem[];
+export declare function useStateReducer(menusDataById: flattenedMenuState | undefined, isNavigatingWithKeyboard: boolean): (state: state, action: menuAction) => state;
+export {};

package/dist-types/cascading-menu/stateChangeTypes.d.ts

@@ -0,0 +1,4 @@
+export declare type stateChangeCause = "keyboardToggle" | "mouseToggle" | "clickedAway" | "onResize" | "itemClicked" | "itemKeydownEnter" | "itemKeydownArrowRight" | "itemKeydownArrowLeft" | "itemKeydownArrowDown" | "itemKeydownArrowUp" | "itemKeydownSpacebar" | "itemKeydownTab" | "itemKeydownEscape" | "itemKeydownHome" | "itemKeydownEnd" | "itemMouseEnter" | "itemMouseMoveToParent" | "mouseOutOfMenus" | "keyboardNavAutoFocus";
+export declare const stateChangeTypes: {
+    [key: string]: stateChangeCause;
+};

package/dist-types/checkbox/Checkbox.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ControlLabelProps } from "../control-label";
+import { CheckboxBaseProps } from "./CheckboxBase";
+import "./Checkbox.css";
+export interface CheckboxProps extends CheckboxBaseProps {
+    label?: ControlLabelProps["label"];
+    LabelProps?: Partial<ControlLabelProps>;
+}
+export declare const Checkbox: import("react").ForwardRefExoticComponent<CheckboxProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/checkbox/CheckboxBase.d.ts

@@ -0,0 +1,18 @@
+import { ChangeEvent, FocusEventHandler, HTMLAttributes, InputHTMLAttributes } from "react";
+import "./CheckboxBase.css";
+export interface CheckboxBaseProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    inputProps?: Partial<InputHTMLAttributes<HTMLInputElement>>;
+    name?: string;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    /**
+     * Callback when checked state is changed
+     */
+    onChange?: (event: ChangeEvent<HTMLInputElement>, checked: boolean) => void;
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    value?: string;
+}
+export declare const CheckboxBase: import("react").ForwardRefExoticComponent<CheckboxBaseProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/checkbox/CheckboxGroup.d.ts

@@ -0,0 +1,35 @@
+import { ChangeEventHandler, HTMLAttributes, ReactNode } from "react";
+import { FormGroupProps } from "../form-group";
+import "./CheckboxGroup.css";
+export interface CheckboxGroupProps extends FormGroupProps {
+    /**
+     * The current checked options.
+     */
+    checkedValues?: string[];
+    /**
+     * The default selected options for un-controlled component.
+     */
+    defaultCheckedValues?: string[];
+    /**
+     * Props spread onto the FormControl component that wraps the checkboxes.
+     */
+    FormControlProps?: Partial<HTMLAttributes<HTMLFieldSetElement>>;
+    /**
+     * Props spread onto the legend.
+     */
+    LegendProps?: unknown;
+    /**
+     * The label for the group legend
+     */
+    legend?: ReactNode;
+    /**
+     * The name used to reference the value of the control.
+     */
+    name?: string;
+    /**
+     * Callback fired when a checkbox is clicked.
+     * `event.target.value` returns the value of the checkbox that was clicked.
+     */
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+}
+export declare const CheckboxGroup: import("react").ForwardRefExoticComponent<CheckboxGroupProps & import("react").RefAttributes<HTMLFieldSetElement>>;

package/dist-types/checkbox/CheckboxIcon.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import "./CheckboxIcon.css";
+export interface CheckboxIconProps {
+    checked?: boolean;
+    className?: string;
+    disabled?: boolean;
+    indeterminate?: boolean;
+}
+export declare const CheckboxIcon: ({ checked, className: classNameProp, disabled, indeterminate, }: CheckboxIconProps) => JSX.Element;

package/dist-types/checkbox/assets/CheckboxCheckedIcon.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare function CheckboxCheckedIcon({ className, }: {
+    className: string;
+}): JSX.Element;

package/dist-types/checkbox/assets/CheckboxIndeterminateIcon.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare function CheckboxIndeterminateIcon({ className, }: {
+    className: string;
+}): JSX.Element;

package/dist-types/checkbox/assets/CheckboxUncheckedIcon.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare function CheckboxUncheckedIcon({ className, }: {
+    className: string;
+}): JSX.Element;

package/dist-types/checkbox/assets/index.d.ts

@@ -0,0 +1,3 @@
+export { CheckboxUncheckedIcon } from "./CheckboxUncheckedIcon";
+export { CheckboxCheckedIcon } from "./CheckboxCheckedIcon";
+export { CheckboxIndeterminateIcon } from "./CheckboxIndeterminateIcon";

package/dist-types/checkbox/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Checkbox";
+export * from "./CheckboxBase";
+export * from "./CheckboxGroup";
+export * from "./CheckboxIcon";
+export * from "./assets";

package/dist-types/checkbox/internal/CheckboxGroupContext.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { CheckboxGroupProps } from "../CheckboxGroup";
+interface CheckboxGroupState {
+    name: CheckboxGroupProps["name"];
+    onChange: CheckboxGroupProps["onChange"];
+    checkedValues: CheckboxGroupProps["checkedValues"];
+}
+declare const CheckboxGroupContext: import("react").Context<CheckboxGroupState | null>;
+export { CheckboxGroupContext };

package/dist-types/color-chooser/AlphaInputField.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import "./RGBAInput.css";
+interface AlphaInputProps {
+    alphaValue: number;
+    showAsOpacity?: boolean;
+    onSubmit: (alpha: number, e?: React.ChangeEvent) => void;
+}
+export declare const AlphaInput: ({ alphaValue, onSubmit, showAsOpacity, }: AlphaInputProps) => JSX.Element;
+export {};

package/dist-types/color-chooser/Color.d.ts

@@ -0,0 +1,14 @@
+export declare type RGBAValue = {
+    r: number;
+    b: number;
+    g: number;
+    a: number;
+};
+export declare class Color {
+    private color;
+    get hex(): string;
+    get rgba(): RGBAValue;
+    static makeColorFromHex(hexValue: string | undefined): Color | undefined;
+    static makeColorFromRGB(r: number, g: number, b: number, a?: number): Color;
+    setAlpha(alpha: number): Color;
+}

package/dist-types/color-chooser/ColorChooser.d.ts

@@ -0,0 +1,20 @@
+import { ChangeEvent } from "react";
+import { ButtonProps } from "@salt-ds/core";
+import { Color } from "./Color";
+import "./ColorChooser.css";
+export interface ColorChooserProps {
+    color: Color | undefined;
+    defaultAlpha?: number;
+    disableAlphaChooser?: boolean;
+    displayHexOnly?: boolean;
+    hideLabel?: boolean;
+    onClear: () => void;
+    onSelect: (color: Color | undefined, finalSelection: boolean, event?: ChangeEvent) => void;
+    placeholder?: string;
+    buttonProps?: Partial<ButtonProps>;
+    saltColorOverrides?: Record<string, string>;
+    showSwatches?: boolean;
+    showColorPicker?: boolean;
+    readOnly?: boolean;
+}
+export declare const ColorChooser: ({ onClear, onSelect, color, showSwatches, showColorPicker, defaultAlpha, disableAlphaChooser, hideLabel, placeholder, buttonProps, saltColorOverrides, readOnly, displayHexOnly, }: ColorChooserProps) => JSX.Element;

package/dist-types/color-chooser/ColorHelpers.d.ts

@@ -0,0 +1,5 @@
+export declare function getColorNameByHexValue(hexValue: string | undefined, disableAlpha?: boolean, saltColorOverrides?: Record<string, string>): string | undefined;
+export declare function hexValueWithoutAlpha(hexValue: string | undefined): string | undefined;
+export declare function getHexValue(hexValue: string | undefined, disableAlpha: boolean): string | undefined;
+export declare const isValidHex: (hex: string | undefined) => boolean;
+export declare const convertColorMapValueToHex: (color: string) => string;

package/dist-types/color-chooser/ColorPicker.d.ts

@@ -0,0 +1,11 @@
+import { ChangeEvent } from "react";
+import { Color } from "./Color";
+import "./ColorPicker.css";
+export interface ColorPickerProps {
+    disableAlphaChooser: boolean;
+    color?: Color;
+    alpha?: number;
+    onChange: (color: Color | undefined, finalSelection: boolean, e?: ChangeEvent) => void;
+    onDialogClosed: () => void;
+}
+export declare const ColorPicker: ({ alpha, disableAlphaChooser, color, onChange, onDialogClosed, }: ColorPickerProps) => JSX.Element;

package/dist-types/color-chooser/DictTabs.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import { TabstripProps } from "../tabs";
+import { ColorPicker, ColorPickerProps } from "./ColorPicker";
+import { Swatches, SwatchesTabProps } from "./Swatches";
+export declare type ColorChooserTabs = {
+    Swatches?: {
+        Component: typeof Swatches;
+        props: SwatchesTabProps;
+    };
+    "Color Picker"?: {
+        Component: typeof ColorPicker;
+        props: ColorPickerProps;
+    };
+};
+export interface DictTabsProps extends Omit<TabstripProps, "tabs" | "renderContent" | "classes"> {
+    hexValue: string | undefined;
+    tabs: ColorChooserTabs;
+    onTabClick: (index: number) => void;
+    activeTab: number;
+}
+export declare const DictTabs: ({ tabs, hexValue, onTabClick, activeTab, ...props }: DictTabsProps) => JSX.Element;

package/dist-types/color-chooser/GetColorPalettes.d.ts

@@ -0,0 +1,2 @@
+export declare function makePalette(colorScheme: string, saltColorOverrides?: Record<string, string>): string[];
+export declare function getColorPalettes(saltColorOverrides?: Record<string, string>): string[][];

package/dist-types/color-chooser/HexInput.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import "./HexInput.css";
+interface HexInputProps {
+    hexValue: string | undefined;
+    disableAlphaChooser: boolean;
+    onSubmit: (hex: string | undefined, e?: React.ChangeEvent) => void;
+}
+export declare const HexInput: ({ hexValue, disableAlphaChooser, onSubmit, }: HexInputProps) => JSX.Element;
+export {};

package/dist-types/color-chooser/HexInputField.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import "./ColorPicker.css";
+interface HexInputProps {
+    hexValue: string | undefined;
+    disableAlphaChooser: boolean;
+    onSubmit: (hex: string | undefined, e?: React.ChangeEvent) => void;
+}
+export declare const HexInput: ({ hexValue, disableAlphaChooser, onSubmit, }: HexInputProps) => JSX.Element;
+export {};

package/dist-types/color-chooser/RGBAInput.d.ts

@@ -0,0 +1,12 @@
+import { ChangeEvent } from "react";
+import { RGBAValue } from "./Color";
+import "./RGBAInput.css";
+interface RGBAInputProps {
+    disableAlphaChooser: boolean;
+    rgbaText: string;
+    rgbaValue: RGBAValue;
+    onSubmitRgb: (rgbaValue: RGBAValue, e?: ChangeEvent<Element> | undefined) => void;
+    onSubmitAlpha: (alpha: number, e?: ChangeEvent<Element> | undefined) => void;
+}
+export declare const RGBAInput: ({ disableAlphaChooser, rgbaText, rgbaValue, onSubmitAlpha, onSubmitRgb, }: RGBAInputProps) => JSX.Element;
+export {};

package/dist-types/color-chooser/RGBAInputField.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { RGBAValue } from "./Color";
+import "./RGBAInput.css";
+interface RGBInputProps {
+    rgbaValue: RGBAValue;
+    value: "r" | "g" | "b";
+    onSubmit: (rgb: RGBAValue, e?: React.ChangeEvent) => void;
+}
+export declare const RGBInput: ({ rgbaValue, value, onSubmit, }: RGBInputProps) => JSX.Element;
+export {};

package/dist-types/color-chooser/Swatch.d.ts

@@ -0,0 +1,12 @@
+import { ChangeEvent } from "react";
+import { Color } from "./Color";
+interface SwatchProps {
+    active: boolean;
+    alpha: number;
+    color: string;
+    onClick: (color: Color | undefined, finalSelection: boolean, e?: ChangeEvent) => void;
+    onDialogClosed: () => void;
+    transparent?: boolean;
+}
+export declare const Swatch: ({ color, onClick, active, alpha, onDialogClosed, transparent, }: SwatchProps) => JSX.Element;
+export {};

package/dist-types/color-chooser/Swatches.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { Color } from "./Color";
+import "./Swatches.css";
+export interface SwatchesTabProps {
+    allColors: string[][];
+    color: Color | undefined;
+    alpha: number;
+    handleColorChange: (color: Color | undefined, finalSelection: boolean, e?: React.ChangeEvent) => void;
+    displayColorName: string | undefined;
+    placeholder: string | undefined;
+    onDialogClosed: () => void;
+}
+export declare const Swatches: ({ allColors, color, alpha, handleColorChange, displayColorName, placeholder, onDialogClosed, }: SwatchesTabProps) => JSX.Element;

package/dist-types/color-chooser/SwatchesPicker.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Color } from "./Color";
+import "./Swatch.css";
+interface SwatchesPickerProps {
+    allColors: string[][];
+    color: Color | undefined;
+    alpha?: number;
+    onChange: (color: Color | undefined, finalSelection: boolean, e?: React.ChangeEvent) => void;
+    onDialogClosed: () => void;
+}
+export declare const SwatchesPicker: ({ allColors, color, alpha, onChange, onDialogClosed, }: SwatchesPickerProps) => JSX.Element;
+export {};

package/dist-types/color-chooser/color-utils.d.ts

@@ -0,0 +1 @@
+export declare const isTransparent: (color?: string | undefined) => boolean;