@skedulo/sked-ui 0.0.1 → 0.0.2-react-18-upgrade-test

package/dist/components/popout/PopOutBase.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import * as PopperJS from '@popperjs/core';
+import { StrictModifier } from 'react-popper';
+export interface IPopOutBase {
+    /**
+     * The element you are rendering the content from
+     */
+    className?: string;
+    /**
+     * Whether to add inline-block to the reference element
+     */
+    displayInline?: boolean;
+    trigger: JSX.Element;
+    triggerClassName?: string;
+    visible?: boolean;
+    /**
+     * Placement options supported by PopperJS
+     */
+    placement?: PopperJS.Options['placement'];
+    /**
+     * Modifiers supported by PopperJS if overriding defaults
+     */
+    modifiers?: PopperJS.Options['modifiers'];
+    /**
+     * Optional PopOut container to override Portal component if needed
+     */
+    popOutContainer?: (PopperWrappedContent: JSX.Element) => JSX.Element;
+    children?: React.ReactNode;
+    showArrow?: boolean;
+}
+export declare const DEFAULT_MODIFIERS: StrictModifier[];
+/**
+ * PopOutBase uses react-popper/popperjs under the hood and is a wrapper that sets up the Popperjs Manager, Reference and Popper.
+ * It will place any content next to the trigger based on whether it fits and what placement you specify.
+ * If you need click show/hide functionality, use @PopOut
+ *
+ * @requires react-popper
+ */
+export declare const PopOutBase: React.FC<IPopOutBase>;

package/dist/components/popout/usePopOut.d.ts

@@ -0,0 +1,9 @@
+import { IPopOutProps } from './PopOut';
+declare type UsePopOutProps = Pick<IPopOutProps, 'delayShow' | 'preventShow' | 'onClose' | 'openOnMount'>;
+export declare const usePopOut: ({ delayShow, preventShow, onClose, openOnMount }: UsePopOutProps) => {
+    visible: boolean;
+    openPopOut: () => void;
+    closePopOut: () => void;
+    togglePopOut: () => void;
+};
+export {};

package/dist/components/popups/info-window/InfoWindow.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import { IPopOutProps } from '../../popout/PopOut';
+import { ICursorOptions } from './info-window-utils';
+export interface IRequiredProps {
+    /**
+     * Content to be shown inside the info window
+     */
+    content: JSX.Element | JSX.Element[] | React.ReactNode | string;
+    /**
+     * Preferred direction around the trigger to open the info window
+     */
+    position: IPopOutProps['placement'];
+}
+export declare type IPopOutPropsSubset = IRequiredProps & Omit<IPopOutProps, 'children' | 'trigger' | 'showArrow'>;
+export declare type IInfoWindowEvent = 'click' | 'mount';
+export declare type IInfoWindowProps = IPopOutPropsSubset & {
+    children: React.ReactNode;
+    /**
+     * Event type used to trigger the info window, 'hover' is now deprecated
+     */
+    event?: IInfoWindowEvent;
+    /**
+     * Deprecated: Cursor options control what happens to the info window while moving the mouse within the trigger
+     */
+    cursorOption?: ICursorOptions;
+    /**
+     * ClassName to be given to the wrapper around the info window content
+     */
+    containerClassName?: string;
+    /**
+     * Data attributes to be applied to the wrapper around the trigger component
+     */
+    dataAttributes?: {
+        [key: string]: string;
+    };
+    /**
+     * Render a close button within the wrapper around the info window content
+     */
+    withCloseButton?: boolean;
+    /**
+     * Styles to apply to the wrapper around the trigger component
+     */
+    style?: React.CSSProperties;
+};
+export declare const InfoWindow: (props: IInfoWindowProps) => React.JSX.Element;

package/dist/components/popups/info-window/InfoWindow.stories.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/popups/info-window/LegacyInfoWindow.d.ts

@@ -0,0 +1,161 @@
+import * as React from 'react';
+import { IAnchorScores, ICursorOptions, ICursorPoints, Position } from './info-window-utils';
+declare type ILegacyInfoWindowEvent = 'click' | 'hover' | 'mount';
+interface IInfoWindowStyles<T> {
+    triangleStyles: {
+        top: T;
+        left: T;
+    };
+    contentStyles: {
+        top: T;
+        left: T;
+    };
+}
+export interface ILegacyInfoWindowRequiredProps {
+    /**
+     * Content to be shown inside the info window
+     */
+    content: JSX.Element | JSX.Element[] | React.ReactNode | string;
+    /**
+     * Preferred direction around the trigger to open the info window
+     */
+    position: Position;
+}
+export declare type ILegacyInfoWindowProps = ILegacyInfoWindowRequiredProps & {
+    children?: React.ReactNode;
+    /**
+     * ILegacyInfoWindowEvent type used to trigger the info window
+     */
+    event?: ILegacyInfoWindowEvent;
+    /**
+     * Cursor options control what happens to the info window while moving the mouse within the trigger
+     */
+    cursorOption?: ICursorOptions;
+    /**
+     * Delay render of the info window after the trigger event has been fired
+     */
+    delayShow?: number;
+    /**
+     * Prevent the display of the pop out regardless of the trigger event
+     */
+    preventShow?: boolean;
+    /**
+     * ClassName to be given to the wrapper around the info window content
+     */
+    containerClassName?: string;
+    /**
+     * ClassName to be given to the wrapper around the trigger component
+     */
+    className?: string;
+    /**
+     * Data attributes to be applied to the wrapper around the trigger component
+     */
+    dataAttributes?: {
+        [key: string]: string;
+    };
+    /**
+     * Apply 'display: inline-block' style to the wrapper around the trigger component
+     */
+    displayInline?: boolean;
+    /**
+     * Render a close button within the wrapper around the info window content
+     */
+    withCloseButton?: boolean;
+    /**
+     * Offset the trigger points used to calculate the render positions by this number of pixels
+     */
+    positionOffset?: number;
+    /**
+     * Will be called when the mouse over event is fired on the trigger component
+     */
+    onMouseOver?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    /**
+     * Will be called when the mouse leave event is fired on the trigger component
+     */
+    onMouseLeave?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    /**
+     * Will be called when the info window is closed (regardless of the trigger event)
+     */
+    onClose?: () => void;
+    /**
+     * Styles to apply to the wrapper around the trigger component
+     */
+    style?: React.CSSProperties;
+};
+interface IState {
+    show: boolean;
+}
+/**
+ *  The LegacyInfoWindow module allows us to create an element next to an element. By setting props, we can determine the direction of its placement and how it gets triggered. The infowindow module has some smarts that will
+ detect if it's about to get rendered off the screen. If it is, it will adjust the placement of the infowindow until it can be rendered. If it cannot be rendered in any direction, the code will pick the direction
+ where the least amount of overflow is occuring. The order it tries to find a new placement in is top, right, down, left.
+ The above example uses a button as the trigger for the info window, but any html element can be used as long as its passed as a child of the <InfoWindow /> component
+ */
+export declare class LegacyInfoWindow extends React.PureComponent<ILegacyInfoWindowProps, IState> {
+    private _showDelayId;
+    private _triggerRef;
+    private _renderContainer;
+    private _contentRef;
+    private _triangleRef;
+    private _cursorPosition;
+    private _triggerRect;
+    private _root;
+    constructor(props: ILegacyInfoWindowProps);
+    componentDidMount(): void;
+    componentDidUpdate(oldProps: ILegacyInfoWindowProps): void;
+    componentWillUnmount(): void;
+    computeStylesFromDisplayPosition: (anchor: IAnchorScores, triangleRect: ClientRect) => IInfoWindowStyles<number>;
+    setTriggerRef: (div: HTMLDivElement) => void;
+    setContentRef: (div: HTMLDivElement) => void;
+    setTriangleRef: (span: HTMLSpanElement) => void;
+    showHideToggle: () => void;
+    setShow: (show: boolean) => void;
+    handleBodyClick: (e: MouseEvent) => void;
+    handleScroll: () => void;
+    onTriggerClick: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseOver: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseLeave: (e: React.MouseEvent<any>) => void;
+    onMouseMove: (e: MouseEvent) => void;
+    getDisplayPosition: (triggerPoint: ICursorPoints, triggerRect: ClientRect, triangleRect: ClientRect, contentRect: ClientRect) => IAnchorScores;
+    closeInfoWindow(): void;
+    notTargetArea(e: MouseEvent): boolean;
+    registerMousePosition(e: MouseEvent | React.MouseEvent<any> | null): void;
+    detachEventListeners(): void;
+    attachEventListeners(): void;
+    computeStyles(): {
+        contentStyles: React.CSSProperties;
+        triangleStyles: React.CSSProperties;
+        position: Position;
+    } | {
+        position: Position;
+        triangleStyles: {
+            top: string;
+            left: string;
+        } | {
+            top: string;
+            left: string;
+        };
+        contentStyles: {
+            top: string;
+            left: string;
+        } | {
+            top: string;
+            left: string;
+        };
+    };
+    removeRenderingContainer(): void;
+    createRenderContainer(): HTMLDivElement;
+    createRenderRoot(): void;
+    /**
+     * The first render wont be positioned properly since we don't have the width/height to calculate the position.
+     * `runStyleRender` runs a second render when we have the contentContainer rendered to calculate the position.
+     */
+    renderContent(runStyleRender?: boolean): void;
+    render(): React.JSX.Element;
+}
+export declare const InfoWindowContext: React.Context<InfoWindowState>;
+interface InfoWindowState {
+    closeInfoWindow: () => void;
+}
+export declare const useLegacyInfoWindow: () => InfoWindowState;
+export {};

package/dist/components/popups/info-window/info-window-utils.d.ts

@@ -0,0 +1,43 @@
+export interface ICursorPoints {
+    x: number;
+    y: number;
+}
+export interface ICursorOptions {
+    rule: 'follow' | 'follow-x' | 'follow-y';
+    keepOnMouseMove?: boolean;
+}
+export declare type Position = 'top' | 'right' | 'bottom' | 'left';
+export declare const getPositionEvalOrder: (position: Position) => Position[];
+interface IAnchorPoint {
+    position: Position;
+    point: ICursorPoints;
+}
+export interface IAnchorScores extends IAnchorPoint {
+    display: ClientRect;
+    displayScore: number;
+    distanceScore: number;
+    weightedScore: number;
+}
+export declare const getAnchorPoints: (triggerPoint: ICursorPoints, triggerRect: ClientRect, triangleRect: ClientRect, windowRect: ClientRect, cursorOptions: ICursorOptions) => IAnchorPoint[];
+export declare const getPositionScores: (triggerPoint: ICursorPoints, triggerRect: ClientRect, contentRect: ClientRect, triangleRect: ClientRect, windowRect: ClientRect, cursorOptions: ICursorOptions, anchorOffset?: number) => IAnchorScores[];
+export declare const getBestFit: (desiredOrder: Position[], positionScores: IAnchorScores[]) => IAnchorScores;
+export declare const adjustContentDisplayCoordinates: (anchor: IAnchorScores, windowRect: ClientRect) => {
+    display: {
+        left: number;
+        right: number;
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+        bottom: number;
+        top: number;
+        toJSON(): any;
+    };
+    displayScore: number;
+    distanceScore: number;
+    weightedScore: number;
+    position: Position;
+    point: ICursorPoints;
+};
+export declare const notTargetAreas: (elements: (Element | HTMLElement)[], e: MouseEvent) => boolean;
+export {};

package/dist/components/popups/info-window/info-window-utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/popups/info-window/useInfoWindowModifiers.d.ts

@@ -0,0 +1,2 @@
+import { StrictModifier } from 'react-popper';
+export declare const useInfoWindowModifiers: (updatePositionWhenChanged: any) => (StrictModifier<import("react-popper").StrictModifierNames> | Partial<import("@popperjs/core").Modifier<"handleOverflowPositions", {}>>)[];

package/dist/components/popups/overflow-tooltip/OverflowTooltip.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { ITooltipPosition, ITooltipProps } from '../tooltip/Tooltip';
+export interface IOverflowTooltipProps extends Pick<ITooltipProps, 'dataAttributes'> {
+    children: React.ReactNode;
+    /** Maximum width the element expands to before being cut off */
+    maxWidth?: number;
+    className?: string;
+    tooltipClassName?: string;
+    position?: ITooltipPosition;
+}
+export interface IOverflowTooltipState {
+    overflow: boolean;
+}
+/**
+ * OverflowTooltip will ellipse content after the specified maxWidth prop or from the
+ * parent containers calculated width and apply a Tooltip to allow users to see the full
+ * content on hover
+ * @requires Tooltip
+ */
+export declare class OverflowTooltip extends React.PureComponent<IOverflowTooltipProps, IOverflowTooltipState> {
+    _element: HTMLDivElement;
+    static defaultProps: {
+        position: string;
+    };
+    constructor(props: IOverflowTooltipProps);
+    componentDidMount(): void;
+    refElement: (element: HTMLDivElement) => void;
+    checkOverflow: () => void;
+    isTextOverflow(): boolean;
+    render(): React.JSX.Element;
+}

package/dist/components/popups/tooltip/Tooltip.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { ILegacyInfoWindowProps } from '../info-window/LegacyInfoWindow';
+import { Position } from '../info-window/info-window-utils';
+import './tooltip.scss';
+export declare type ITooltipPosition = Position;
+declare type IColorScheme = 'dark' | 'light';
+declare type IAlignStyle = 'center' | 'left' | 'right';
+export interface ITooltipProps extends ILegacyInfoWindowProps {
+    /**
+     * Colour scheme for the tooltip content.  Available options are 'dark' and 'light'
+     */
+    delayShow?: ILegacyInfoWindowProps['delayShow'];
+    event?: ILegacyInfoWindowProps['event'];
+    colorScheme?: IColorScheme;
+    textAlignment?: IAlignStyle;
+}
+/**
+ * Tooltips are an extended version of the info window that triggers on hover by default, delayed slightly and is styled with tooltip styles
+ */
+export declare const Tooltip: (props: ITooltipProps) => React.JSX.Element;
+export {};

package/dist/components/popups/tooltip/Tooltip.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/popups/tooltip/Tooltip.stories.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/portal/Portal.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+interface IProps {
+    children?: React.ReactNode;
+    position?: Partial<{
+        left: number;
+        top: number;
+        bottom: number;
+        right: number;
+        minWidth: number;
+        maxWidth: number;
+    }>;
+}
+export declare class Portal extends React.PureComponent<IProps, {}> {
+    private _root;
+    private _portalId;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: IProps): void;
+    componentWillUnmount(): void;
+    setRootContainerPosition: () => void;
+    render(): React.JSX.Element;
+}
+export {};

package/dist/components/search-box/SearchBox.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export declare class SearchBox extends React.PureComponent<{
+    placeholder: string;
+    onChange: (value: string) => void;
+    className?: string;
+}, {}> {
+    changeValue: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    render(): React.JSX.Element;
+}

package/dist/components/search-box/SearchBox.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/status-icon/StatusIcon.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+declare type StatusType = 'general' | 'success' | 'warning' | 'error';
+export interface IStatusIconProps {
+    /**
+     * The type of status. (general, success, warning or error)
+     */
+    status: StatusType;
+    className?: string;
+}
+export declare const StatusIcon: React.FC<React.PropsWithChildren<IStatusIconProps>>;
+export {};

package/dist/components/status-icon/StatusIcon.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/status-icon/StatusIcon.stories.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+import * as React from 'react';
+export interface IHeaderCell {
+    name: string;
+    width?: string;
+    className?: string;
+}
+export declare const Table: React.FC<React.PropsWithChildren<React.HTMLAttributes<HTMLTableElement>>>;
+export declare const TableHeadRow: React.FC<React.PropsWithChildren<React.HTMLAttributes<HTMLTableRowElement>>>;
+export declare const TableHead: React.FC<React.PropsWithChildren<{
+    cells: IHeaderCell[];
+    sticky?: boolean;
+    className?: string;
+}>>;
+export declare const TableBody: React.FC<React.PropsWithChildren<unknown>>;
+export declare const TableRow: React.FC<React.PropsWithChildren<React.HTMLAttributes<HTMLTableRowElement>>>;
+export declare const TableCell: React.FC<React.PropsWithChildren<React.TdHTMLAttributes<HTMLTableDataCellElement>>>;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,36 @@
+/// <reference types="lodash" />
+import * as React from 'react';
+import { ITab as Tab, ITabsProps, ITabsState, Theme } from './interfaces';
+export declare type ITab = Tab;
+export declare const getClassNamesByTheme: (theme: string, isActive: boolean, isFocused?: boolean, className?: string) => {
+    menuItem: string;
+    subMenuItem: string;
+    icon: {
+        menu: string;
+    };
+    tabsWrapper: string;
+    tabsList: string;
+};
+/**
+ * Tabs component can be used for sub navigation menu and global navigation menu
+ */
+export declare class Tabs extends React.PureComponent<ITabsProps, ITabsState> {
+    static defaultProps: {
+        theme: Theme;
+        showActiveState: boolean;
+        onClick: (...args: any[]) => void;
+        as: string;
+    };
+    constructor(props: ITabsProps);
+    componentDidUpdate(prevProps: ITabsProps): Promise<void>;
+    componentWillUnmount(): void;
+    onFocusIn: (index: number, ref: React.RefObject<HTMLElement>, nesting: number) => () => void;
+    onFocusOutDebounce: import("lodash").DebouncedFunc<(nesting: number) => void>;
+    asyncSetState: (state: Partial<ITabsState>) => Promise<unknown>;
+    onFocusOut: (nesting: number) => () => void;
+    onSelect: () => void;
+    hasSubMenus: (tab: ITab) => boolean;
+    isTabActive: (tab: ITab) => boolean;
+    renderSubMenus: () => React.JSX.Element[];
+    render(): React.JSX.Element;
+}

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

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { IMenuItemProps } from './interfaces';
+export declare class MenuItem extends React.PureComponent<IMenuItemProps> {
+    private spanRef;
+    private linkRef;
+    render(): React.DetailedReactHTMLElement<{
+        ref: React.RefObject<HTMLAnchorElement>;
+        onClick: (e: React.MouseEvent<HTMLAnchorElement>) => void;
+        onMouseEnter: () => void;
+        href: string;
+        'data-sk-name': string;
+        className: string;
+        onMouseLeave: () => void;
+    } | {
+        ref: React.RefObject<HTMLSpanElement>;
+        onMouseEnter: () => void;
+        onClickCapture: (...args: any[]) => void;
+        'data-sk-name': string;
+        className: string;
+        onMouseLeave: () => void;
+    }, HTMLSpanElement>;
+}

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

@@ -0,0 +1,28 @@
+import { ITab, IRouteMap } from './interfaces';
+/**
+ * get route objects as per the nested path indexes
+ */
+export declare const getRouteFor: (tabs: ITab[], path: number[]) => ITab[];
+/**
+ * map all paths to their respective route objects
+ */
+export declare const mapPathToRouteObject: (tabs: ITab[]) => any;
+/**
+ * Get the active route array by traversing the route map
+ */
+export declare const getActiveRoute: (activeRoute: string, routeMap: IRouteMap) => string[];
+export declare const dropDownTriggerPosition: (trigger: React.RefObject<HTMLElement>, nesting: number) => {
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+    bottom: number;
+    right: number;
+    toJSON(): any;
+};
+/**
+ * return a complete URL route for a submenu item.
+ */
+export declare const getFullRouteForSubMenuItem: (tabs: ITab[], subMenu: ITab) => string;

package/dist/components/tabs/Tabs/__tests__/Tabs.spec.d.ts

@@ -0,0 +1 @@
+export declare const getDefaultTestProps: (additionalProps?: {}) => any;

package/dist/components/tabs/Tabs/__tests__/TabsMenuItem.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/tabs/Tabs/__tests__/TabsRoutingUtils.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,65 @@
+/// <reference types="react" />
+export declare enum Theme {
+    SUB = "sub",
+    GLOBAL = "global"
+}
+export declare type AsMenuType = 'a' | 'span';
+export interface ITab {
+    title: string;
+    route: string;
+    subMenus?: ITab[];
+}
+export interface ITabsProps {
+    tabs: ITab[];
+    onClick: (route: string) => void;
+    currentActiveRoute: string;
+    showActiveState?: boolean;
+    className?: string;
+    theme?: Theme.GLOBAL | Theme.SUB;
+    /**
+     * The tab component will automatically generate 'span' tag links. However, if you specify to generate the menu items as 'a' tags,
+     * then links will be generated based on the route configuration passed in.
+     * Do not explicitly set this if you wish to insert dynamic parameters into the URL based on navigation.
+     */
+    as?: AsMenuType;
+    /**
+     * Used to render all tabs and items.
+     *
+     * Note: that Sked-UI styling will be applied in accordance with the theme prop.
+     * This renderer will render the items within each tab and menu item.
+     *
+     * Default: ({title}) => title
+     */
+    itemRenderer?: IMenuItemProps['itemRenderer'];
+}
+export interface IFocusRouteItem {
+    index: number;
+    ref: React.RefObject<HTMLElement>;
+}
+export interface IRouteMap {
+    [key: string]: ITab;
+}
+export interface ITabsState {
+    activeRoute: string[];
+    focusRoute: IFocusRouteItem[];
+    routeMap: IRouteMap;
+}
+interface IBaseItemProps {
+    label: string;
+    route: string;
+    activeRoute: string[];
+    tabIndex: number;
+    theme: Theme.GLOBAL | Theme.SUB;
+    onFocusIn: (tabIndex: number, ref: React.RefObject<HTMLElement>, nesting: number | null) => () => void;
+    onFocusOut: (nesting: number) => () => void;
+    onSelect: () => void;
+    as?: AsMenuType;
+}
+export interface IMenuItemProps extends Omit<IBaseItemProps, 'theme'> {
+    children: React.ReactNode;
+    focusRoute: IFocusRouteItem[];
+    classes?: string;
+    nesting?: number;
+    itemRenderer?: (tab: Pick<ITab, 'title' | 'route'>) => React.ReactNode;
+}
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/components/text/MultilineContent.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface IMultilineContentProps extends React.HTMLAttributes<HTMLSpanElement> {
+    content: string;
+}
+export declare const MultilineContent: React.FC<React.PropsWithChildren<IMultilineContentProps>>;
+export {};

package/dist/components/text/MultilineContent.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare function useDebounce<T>(value: T, delay?: number): T;