@perawallet/react-ui-toolkit 2.0.0-beta.0

package/dist/select/Select.d.ts

@@ -0,0 +1,19 @@
+import type { JSX } from "react";
+import "./_select.scss";
+import type { Ref } from "react";
+import SelectContent from "./content/SelectContent";
+import SelectGroup from "./group/SelectGroup";
+import SelectItem from "./item/SelectItem";
+import SelectItemList from "./item-list/SelectItemList";
+import SelectTrigger from "./trigger/SelectTrigger";
+import type { Option, SelectProps } from "./util/selectTypes";
+declare const _default: (<T extends Option = Option>(props: SelectProps<T> & {
+    ref?: Ref<HTMLDivElement>;
+}) => JSX.Element) & {
+    Content: typeof SelectContent;
+    Group: typeof SelectGroup;
+    Item: typeof SelectItem;
+    Trigger: typeof SelectTrigger;
+    ItemList: typeof SelectItemList;
+};
+export default _default;

package/dist/select/content/SelectContent.d.ts

@@ -0,0 +1,9 @@
+import "./_select-content.scss";
+import type React from "react";
+export interface SelectContentProps {
+    children: React.ReactNode;
+    customClassName?: string;
+    testid?: string;
+}
+declare const SelectContent: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLDivElement>>;
+export default SelectContent;

package/dist/select/group/SelectGroup.d.ts

@@ -0,0 +1,8 @@
+import type React from "react";
+export type SelectGroupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    customClassName?: string;
+};
+declare const SelectGroup: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+    customClassName?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+export default SelectGroup;

package/dist/select/item/SelectItem.d.ts

@@ -0,0 +1,17 @@
+import type { JSX } from "react";
+import "./_select-item.scss";
+import type React from "react";
+import type { Ref } from "react";
+import type { Option, SelectItemElement } from "../util/selectTypes";
+export interface SelectItemProps<T extends Option = Option> {
+    option: T | null;
+    children: React.ReactNode;
+    customClassName?: string;
+    onKeyDown?: (option: T | null, event: React.KeyboardEvent<SelectItemElement>) => void;
+    as?: keyof Pick<JSX.IntrinsicElements, "div" | "li">;
+    testid?: string;
+}
+declare const _default: <T extends Option = Option>(props: SelectItemProps<T> & {
+    ref?: Ref<SelectItemElement>;
+}) => JSX.Element;
+export default _default;

package/dist/select/item-list/SelectItemList.d.ts

@@ -0,0 +1,13 @@
+import type React from "react";
+import type { JSX, Ref } from "react";
+import type { ListProps } from "../..";
+import type { Option } from "../util/selectTypes";
+export type SelectItemListProps<T extends Option = Option> = {
+    options: T[];
+    contentRenderer: (option: T) => React.ReactNode;
+    customClassName?: string;
+} & Omit<ListProps, "items" | "ref" | "children">;
+declare const _default: <T extends Option = Option>(props: SelectItemListProps<T> & {
+    ref?: Ref<HTMLUListElement>;
+}) => JSX.Element;
+export default _default;

package/dist/select/trigger/SelectTrigger.d.ts

@@ -0,0 +1,6 @@
+import type React from "react";
+import type { ButtonProps } from "../../button/Button";
+import "./_select-trigger.scss";
+export type SelectTriggerProps = Omit<ButtonProps, "type">;
+declare const SelectTrigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+export default SelectTrigger;

package/dist/select/typeahead/TypeaheadSelect.d.ts

@@ -0,0 +1,26 @@
+import type React from "react";
+import type { TypeaheadInputProps } from "../../form/input/typeahead/TypeaheadInput";
+import type { Option, TypeaheadSelectOption, TypeaheadSelectOptionSelectHandler } from "../util/selectTypes";
+import "./_typeahead-select.scss";
+export interface TypeaheadSelectProps<T extends TypeaheadSelectOption = TypeaheadSelectOption> {
+    selectedOptions: T[];
+    options: T[];
+    onSelect: TypeaheadSelectOptionSelectHandler<T>;
+    typeaheadProps: Pick<TypeaheadInputProps, "id" | "placeholder" | "name" | "onFocus" | "type">;
+    testid?: string;
+    onKeywordChange?: (value: string) => void;
+    initialKeyword?: string;
+    controlledKeyword?: string;
+    onTagRemove?: (option: Option) => void;
+    selectedOptionLimit?: number;
+    customClassName?: string;
+    shouldDisplaySelectedOptions?: boolean;
+    shouldFilterOptionsByKeyword?: boolean;
+    isDisabled?: boolean;
+    customSpinner?: React.ReactNode;
+    shouldShowEmptyOptions?: boolean;
+    canOpenDropdownMenu?: boolean;
+    areOptionsFetching?: boolean;
+}
+declare function TypeaheadSelect<T extends TypeaheadSelectOption = TypeaheadSelectOption>({ testid, options, selectedOptions, typeaheadProps, onTagRemove, onKeywordChange, onSelect, customClassName, selectedOptionLimit, shouldDisplaySelectedOptions, shouldFilterOptionsByKeyword, isDisabled, shouldShowEmptyOptions, canOpenDropdownMenu, areOptionsFetching, customSpinner, initialKeyword, controlledKeyword }: TypeaheadSelectProps<T>): React.JSX.Element;
+export default TypeaheadSelect;

package/dist/select/typeahead/trigger/TypeheadSelectTrigger.d.ts

@@ -0,0 +1,20 @@
+import "./_typehead-select-trigger.scss";
+import type React from "react";
+import type { TagShape } from "../../../tag/Tag";
+export interface TypeheadSelectTriggerProps {
+    tags: TagShape[];
+    handleTagRemove: (tag: TagShape) => void;
+    customClassName?: string;
+    input?: React.ReactNode;
+    canOpenMenu?: boolean;
+}
+/**
+ * Not a `Select.Trigger`: that renders a `<button>`, and this trigger contains the search
+ * `<input>` and the tags' remove buttons. Interactive controls cannot be nested, and the
+ * button's click toggle meant clicking into the input while the menu was open closed it. The
+ * menu opens when the input inside gains focus (React's onFocus bubbles) and only ever opens —
+ * closing is the `Select`'s job (outside click, selection, keyboard). Deliberately no onClick:
+ * a click on a tag's remove button would bubble here too, and the input already fills the row.
+ */
+declare function TypeheadSelectTrigger({ handleTagRemove, tags, customClassName, input, canOpenMenu }: TypeheadSelectTriggerProps): React.JSX.Element;
+export default TypeheadSelectTrigger;

package/dist/select/typeahead/util/typeaheadSelectUtils.d.ts

@@ -0,0 +1,3 @@
+import type { TypeaheadSelectOption } from "../../util/selectTypes";
+declare function filterOptionsByKeyword<T extends TypeaheadSelectOption = TypeaheadSelectOption>(options: T[], keyword: string): T[];
+export { filterOptionsByKeyword };

package/dist/select/util/context/SelectContext.d.ts

@@ -0,0 +1,7 @@
+import type { Dispatch } from "react";
+import type { SelectContextValue, SelectStateAction } from "../selectTypes";
+declare const SelectContext: import("react").Context<SelectContextValue | null>;
+declare const SelectDispatchContext: import("react").Context<Dispatch<SelectStateAction> | null>;
+declare function useSelectContext(): SelectContextValue;
+declare function useSelectDispatchContext(): Dispatch<SelectStateAction>;
+export { SelectContext, SelectDispatchContext, useSelectContext, useSelectDispatchContext };

package/dist/select/util/context/SelectContext.reducer.d.ts

@@ -0,0 +1,3 @@
+import type { SelectOwnState, SelectStateAction } from "../selectTypes";
+declare function selectStateReducer(state: SelectOwnState, action: SelectStateAction): SelectOwnState;
+export { selectStateReducer };

package/dist/select/util/hook/useMultiSelect.d.ts

@@ -0,0 +1,14 @@
+import type { Option } from "../selectTypes";
+/**
+ * A hook to handle default multi select behavior.
+ * @param initialValue - initial value of the select
+ * @returns {Object} - An object with the following properties:
+ *  - value: the current value of the select
+ * - handleSelect: a function that can be used to set the value of the select with default behavior (if the value is exists,
+ *  it will remove passed option from value, otherwise the option will be added to value)
+ */
+declare function useMultiSelect<T extends Option = Option>(initialValue?: T[]): {
+    value: T[];
+    handleSelect: (option: T) => void;
+};
+export default useMultiSelect;

package/dist/select/util/hook/useSelectClassName.d.ts

@@ -0,0 +1,12 @@
+import type { SelectContextValue } from "../selectTypes";
+/**
+ * A hook that returns the class name for the select component.
+ * @param state - Select state
+ * @param customClassName - Custom class name
+ * @returns {string} - Select container className according to the provided state object
+ * @example
+ * const selectClassName = useSelectClassName(state, customClassName);
+ * <div className={selectClassName} ... />
+ */
+declare function useSelectClassName(state: SelectContextValue, customClassName?: string): string;
+export default useSelectClassName;

package/dist/select/util/hook/useSelectKeyDown.d.ts

@@ -0,0 +1,18 @@
+import type React from "react";
+import type { SelectContextValue, SelectStateAction } from "../selectTypes";
+/**
+ * A hook for handle select key down event.
+ * @param state - Select state
+ * @param dispatch - Select state dispatch function
+ * @returns {Object} - An object that contains select key down handler
+ * @example
+ * const {handleSelectKeyDown} = useSelectKeyDown(state, dispatch);
+ * <div
+ *  onKeyDown={handleSelectKeyDown}
+ *  ...
+ * />
+ */
+declare function useSelectKeyDown(state: SelectContextValue, dispatch: React.Dispatch<SelectStateAction>): {
+    handleSelectKeyDown: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+};
+export default useSelectKeyDown;

package/dist/select/util/hook/useSingleSelect.d.ts

@@ -0,0 +1,13 @@
+import type { Option } from "../selectTypes";
+/**
+ * A hook to handle default single select behavior.
+ * @param initialValue - initial value of the select
+ * @returns {Object} - An object with the following properties:
+ *  - value: the current value of the select
+ *  - handleSelect: a function that can be used to set the value of the select
+ */
+declare function useSingleSelect<T extends Option = Option>(initialValue?: T): {
+    value: T | null;
+    handleSelect: (option: T | null) => void;
+};
+export default useSingleSelect;

package/dist/select/util/selectTypes.d.ts

@@ -0,0 +1,40 @@
+import type React from "react";
+interface Option {
+    id: string;
+    isDisabled?: boolean;
+}
+interface TypeaheadSelectOption extends Option {
+    title: string;
+}
+type SelectItemElement = HTMLLIElement | HTMLDivElement;
+type OptionSelectHandler<T extends Option = Option> = (option: T | null, event?: React.SyntheticEvent<SelectItemElement>) => void;
+type TypeaheadSelectOptionSelectHandler<T extends TypeaheadSelectOption = TypeaheadSelectOption> = (option: T, event?: React.SyntheticEvent<SelectItemElement>) => void;
+type SelectRole = "listbox" | "menu";
+interface SelectProps<T extends Option = Option> {
+    children: React.ReactNode;
+    options: (Option | null)[];
+    value: SelectValue<T>;
+    onSelect: OptionSelectHandler<T>;
+    role?: SelectRole;
+    hasError?: boolean;
+    customClassName?: string;
+    isDisabled?: boolean;
+    shouldCloseOnSelect?: boolean;
+    isMenuOpen?: boolean;
+}
+type SelectContextValue = Pick<SelectProps, "hasError" | "isDisabled" | "onSelect" | "shouldCloseOnSelect" | "value" | "role"> & SelectOwnState;
+interface SelectOwnState {
+    isMenuOpen: boolean;
+    focusedOptionIndex: number;
+    options: (Option | null)[];
+}
+type SelectValue<T extends Option> = T | T[] | null;
+type SelectStateAction = {
+    type: "TOGGLE_MENU_VISIBILITY";
+} | {
+    type: "OPEN_MENU";
+} | {
+    type: "SET_FOCUSED_OPTION_INDEX";
+    payload: number;
+};
+export type { Option, OptionSelectHandler, SelectContextValue, SelectItemElement, SelectOwnState, SelectProps, SelectRole, SelectStateAction, TypeaheadSelectOption, TypeaheadSelectOptionSelectHandler };

package/dist/select/util/selectUtils.d.ts

@@ -0,0 +1,9 @@
+import type { SelectContextValue, SelectOwnState, SelectProps } from "./selectTypes";
+/**
+ * Generates select state from provided props.
+ * @param {SelectContextValue} state - The current state of the select
+ * @param props - The props passed to the select
+ * @returns {SelectContextValue} - The new state of the select
+ */
+declare function generateSelectState(state: SelectOwnState, props: SelectProps): SelectContextValue;
+export { generateSelectState };

package/dist/spinner/Spinner.d.ts

@@ -0,0 +1,7 @@
+import "./_spinner.scss";
+export interface SpinnerProps {
+    color?: string;
+    customClassName?: string;
+}
+declare function Spinner({ color, customClassName }: SpinnerProps): import("react").JSX.Element;
+export default Spinner;

package/dist/switch/Switch.d.ts

@@ -0,0 +1,10 @@
+import "./_switch.scss";
+export interface SwitchProps {
+    onToggle: () => void;
+    isToggledOn: boolean;
+    isDisabled?: boolean;
+    customClassName?: string;
+    testid?: string;
+}
+declare function Switch({ onToggle, isToggledOn, isDisabled, customClassName, testid }: SwitchProps): import("react").JSX.Element;
+export default Switch;

package/dist/tab/Tab.d.ts

@@ -0,0 +1,27 @@
+import "./_tab.scss";
+import type React from "react";
+export type TabItem = {
+    id: string;
+    content: React.ReactNode;
+    icon?: React.ReactNode;
+    isDisabled?: boolean;
+};
+interface UncontrolledTabProps {
+    items: TabItem[];
+    children: React.ReactNode[];
+    testid?: string;
+    initialActiveTabIndex?: number;
+    customClassName?: string;
+    wrapperId?: string;
+}
+type ControlledTabProps = {
+    activeTabIndex: number;
+    onTabChange: (index: number) => void;
+    initialActiveTabIndex?: number;
+} | {
+    activeTabIndex?: number;
+    onTabChange?: (index: number) => void;
+};
+export type TabProps = ControlledTabProps & UncontrolledTabProps;
+declare function Tab({ testid, items, initialActiveTabIndex, activeTabIndex: activeTabIndexFromProps, children, customClassName, onTabChange, wrapperId }: TabProps): React.JSX.Element;
+export default Tab;

package/dist/tab/header/item/TabHeaderItem.d.ts

@@ -0,0 +1,11 @@
+import "./_tab-header-item.scss";
+import type { TabItem } from "../../Tab";
+type TabHeaderItemProps = {
+    tab: TabItem;
+    onClick: (index: number) => void;
+    isActive: boolean;
+    index: number;
+    testid?: string;
+};
+declare function TabHeaderItem({ testid, tab, onClick, index, isActive }: TabHeaderItemProps): import("react").JSX.Element;
+export default TabHeaderItem;

package/dist/tag/Tag.d.ts

@@ -0,0 +1,15 @@
+import "./_tag.scss";
+import type React from "react";
+export interface TagShape<Context = any> {
+    id: string;
+    content: React.ReactNode;
+    context?: Context;
+}
+interface TagProps {
+    tag: TagShape;
+    testid?: string;
+    customClassName?: string;
+    onRemove?: (tag: TagShape) => void;
+}
+declare function Tag({ testid, tag, onRemove, customClassName }: TagProps): React.JSX.Element;
+export default Tag;

package/dist/tag/util/tagUtils.d.ts

@@ -0,0 +1,4 @@
+import type { TypeaheadSelectOption } from "../../select/util/selectTypes";
+import type { TagShape } from "../Tag";
+declare function mapOptionsToTagShapes<T extends TypeaheadSelectOption = TypeaheadSelectOption>(options: T[]): TagShape<T>[];
+export { mapOptionsToTagShapes };

package/dist/timeUtils-BvuzU1KM.js

@@ -0,0 +1 @@
+"use strict";var e=require("date-fns/fp"),t=require("date-fns/locale"),r=require("date-fns-tz");const n=1e3,a=3600,o={DEFAULT:"MMM d, yyyy",LONG_TIME_FORMAT:"hh:mm a"};function i(e){return[e[0],e[1]].sort((e,t)=>e.getTime()-t.getTime())}exports.DATE_FORMAT=o,exports.SECOND_IN_MS=n,exports.calculateRemainingTimeBreakdown=function(e,t=0,r="down"){let o,s;e.length>1||"up"===r?[o,s]=i([e[0],e[1]||new Date]):(s=e[0],o=new Date);const g=s.getTime()-o.getTime(),l=(g-t)/n;return{delta:g,days:Math.floor(l/86400),hours:Math.floor(l/a%24),minutes:Math.floor(l%a/60),seconds:Math.floor(l%a%60)}},exports.formatDateWithOptions=function(n){const{format:a=o.DEFAULT,shouldShiftDateToCompensateForTimezone:i=!0,isProvidedDateInUTC:s=!0,timeZone:g}=n||{};return n=>{let o=n;return g?s&&(o=r.toZonedTime(n,g)):i&&(o=function(e){return new Date(e.getTime()- -1*e.getTimezoneOffset()*6e4)}(n)),g?r.format(o,a,{locale:t.enCA,timeZone:g}):e.formatWithOptions({locale:t.enCA},a)(o)}},exports.parseTime=function(e,t="g:i A"){const r=e.replace(/[^0-9]/g,"");let n,a,o=null!==e.match(/p/i);switch(r.length){case 4:n=parseInt(r[0]+r[1],10),a=parseInt(r[2]+r[3],10);break;case 3:n=parseInt(r[0],10),a=parseInt(r[1]+r[2],10);break;case 2:case 1:n=parseInt(r[0]+(r[1]||""),10),a=0;break;default:return""}return o&&n>0&&n<12&&(n+=12),n>=13&&n<=23&&(o=!0),(n<=0||n>=24)&&(n=0),(a<0||a>59)&&(a=0),t.replace(/g/g,0===n?"12":"g").replace(/g/g,n>12?(n-12).toString().padStart(2,"0"):n.toString().padStart(2,"0")).replace(/G/g,String(n)).replace(/h/g,String(n.toString().length>1?n>12?n-12:n:`0${n>12?n-12:n}`)).replace(/H/g,String(n.toString().length>1?n:`0${n}`)).replace(/i/g,String(a.toString().length>1?a:`0${a}`)).replace(/s/g,"00").replace(/a/g,o?"pm":"am").replace(/A/g,o?"PM":"AM")},exports.sortDateRange=i;

package/dist/toast/Toast.d.ts

@@ -0,0 +1,11 @@
+import ToastCloseButton from "./close-button/ToastCloseButton";
+import type { ToastContextState } from "./util/toastTypes";
+export interface ToastProps {
+    testid: string;
+    data: ToastContextState["toastStack"][0];
+}
+declare function Toast({ testid, data }: ToastProps): import("react").JSX.Element;
+declare namespace Toast {
+    var CloseButton: typeof ToastCloseButton;
+}
+export default Toast;

package/dist/toast/ToastItemContext.d.ts

@@ -0,0 +1,5 @@
+type ToastItemContextValue = {
+    toastId: string;
+};
+declare const ToastItemContext: import("react").Context<ToastItemContextValue>;
+export { ToastItemContext };

package/dist/toast/ToastProvider.d.ts

@@ -0,0 +1,17 @@
+import type React from "react";
+import type { ToastAction, ToastContextState } from "./util/toastTypes";
+declare const ToastStateContext: React.Context<ToastContextState | null>;
+declare const ToastDispatchContext: React.Context<React.Dispatch<ToastAction> | null>;
+interface ToastContextProviderProps {
+    children: React.ReactNode;
+    customRootId?: string;
+    autoCloseToasts?: boolean;
+    limit?: number;
+    defaultAutoCloseTimeout?: number;
+}
+/**
+ * Wraps its children in a context provider
+ * these children can then use the useToast hook to show toast messages
+ */
+declare function ToastContextProvider({ children, customRootId, autoCloseToasts, limit, defaultAutoCloseTimeout }: ToastContextProviderProps): React.JSX.Element;
+export { ToastContextProvider, ToastDispatchContext, ToastStateContext };

package/dist/toast/close-button/ToastCloseButton.d.ts

@@ -0,0 +1,8 @@
+import "./_toast-close-button.scss";
+import type React from "react";
+interface ToastCloseButtonProps {
+    children: React.ReactNode;
+    testid?: string;
+}
+declare function ToastCloseButton({ children, testid }: ToastCloseButtonProps): React.JSX.Element;
+export default ToastCloseButton;

package/dist/toast/stack/ToastStack.d.ts

@@ -0,0 +1,6 @@
+import "./_toast-stack.scss";
+interface ToastStackProps {
+    customRootId?: string;
+}
+declare function ToastStack({ customRootId }: ToastStackProps): import("react").ReactPortal | null;
+export default ToastStack;

package/dist/toast/util/toastConstants.d.ts

@@ -0,0 +1,4 @@
+import type { ToastContextState } from "./toastTypes";
+declare const DEFAULT_TOAST_TIMEOUT = 4000;
+declare const initialToastState: ToastContextState;
+export { DEFAULT_TOAST_TIMEOUT, initialToastState };

package/dist/toast/util/toastHooks.d.ts

@@ -0,0 +1,28 @@
+import type { ToastContextState, ToastData } from "./toastTypes";
+/**
+ * @returns {Object} Current value of ToastContextState
+ */
+declare function useToastContextState(): ToastContextState;
+declare function useToaster(): {
+    /**
+     * Display a Toast
+     * @returns {string} Toast's id
+     */
+    display: (toastData: ToastData) => string;
+    /**
+     * Hide a Toast with a given id
+     */
+    hide: (toastId: string) => void;
+    /**
+     * Updates the data for a Toast given its ID
+     */
+    update: (toastId: string, toastData: Partial<ToastData>) => void;
+    /**
+     * Hide all visible Toasts
+     */
+    hideAll: () => void;
+};
+declare function useToastItemContext(): {
+    toastId: string;
+};
+export { useToastContextState, useToaster, useToastItemContext };

package/dist/toast/util/toastReducer.d.ts

@@ -0,0 +1,5 @@
+import type { initialToastState } from "./toastConstants";
+import type { ToastAction } from "./toastTypes";
+type ToastState = typeof initialToastState;
+declare function toastReducer(state: ToastState, action: ToastAction): ToastState;
+export default toastReducer;

package/dist/toast/util/toastTypes.d.ts

@@ -0,0 +1,39 @@
+export interface ToastData {
+    render: () => React.ReactNode;
+    id?: string;
+    autoClose?: boolean;
+    timeout?: number;
+    customClassName?: string;
+}
+export type ToastAction = {
+    type: "DISPLAY";
+    toastData: Omit<ToastData, "id"> & {
+        id: string;
+    };
+} | {
+    type: "HIDE";
+    toastId: string;
+} | {
+    type: "HIDE_ALL";
+} | {
+    type: "UPDATE";
+    toastId: string;
+    toastData: Partial<Omit<ToastData, "id">>;
+} | {
+    type: "SET_LIMIT";
+    limit: number;
+} | {
+    type: "SET_AUTO_CLOSE";
+    autoCloseToasts: boolean;
+} | {
+    type: "SET_DEFAULT_AUTO_CLOSE_TIMEOUT_FOR_ALL_TOASTS";
+    timeout: undefined | number;
+};
+export interface ToastContextState {
+    toastStack: (Omit<ToastData, "id"> & {
+        id: string;
+    })[];
+    autoCloseToasts: boolean;
+    defaultAutoCloseTimeout: number;
+    limit?: number;
+}

package/dist/toast/util/toastUtils.d.ts

@@ -0,0 +1,3 @@
+import type { ToastData } from "./toastTypes";
+declare function isSameToast(toastId: string): (toast2: ToastData) => boolean;
+export { isSameToast };

package/dist/toggle/Toggle.d.ts

@@ -0,0 +1,18 @@
+import "./_toggle.scss";
+import type React from "react";
+import ToggleItem from "./item/ToggleItem";
+import { ToggleContext } from "./util/ToggleContext";
+export interface ToggleProps {
+    children: React.ReactNode;
+    onToggle: (selectedItems: string[]) => void;
+    selectedItems: string[];
+    canSelectMultiple?: boolean;
+    position?: "vertical" | "horizontal";
+    isDisabled?: boolean;
+    customClassName?: string;
+}
+declare function Toggle({ children, onToggle, selectedItems, canSelectMultiple, position, isDisabled, customClassName }: ToggleProps): React.JSX.Element;
+declare namespace Toggle {
+    var Item: typeof ToggleItem;
+}
+export { Toggle, ToggleContext };

package/dist/toggle/item/ToggleItem.d.ts

@@ -0,0 +1,11 @@
+import "./_toggle-item.scss";
+import type React from "react";
+export interface ToggleItemProps {
+    children: React.ReactNode;
+    dataId: string;
+    customClassName?: string;
+    isDisabled?: boolean;
+    testid?: string;
+}
+declare function ToggleItem({ children, dataId, customClassName, isDisabled, testid }: ToggleItemProps): React.JSX.Element;
+export default ToggleItem;

package/dist/toggle/util/ToggleContext.d.ts

@@ -0,0 +1,8 @@
+type ToggleContextValue = {
+    selectedItems: string[];
+    onToggle: (selectedItems: string[]) => void;
+    canSelectMultiple?: boolean;
+};
+declare const ToggleContext: import("react").Context<ToggleContextValue>;
+declare function useToggle(): ToggleContextValue;
+export { ToggleContext, useToggle };

package/dist/useDebounce-CP74COv3.js

@@ -0,0 +1 @@
+"use strict";var e=require("react");exports.useDebounce=function(t,r,u){const[c,s]=e.useState(r),n=e.useRef(c);return e.useEffect(()=>{let e;return n.current!==c&&(e=setTimeout(()=>{t(c)},u),n.current=c),()=>{clearTimeout(e)}},[n,t,c,u]),[c,s]};