@skedulo/sked-ui 20.2.0 → 21.0.0-beta.1

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

@@ -8,7 +8,9 @@ export interface IPopOutProps {
     /**
      * The content to pop out
      */
-    children: (hideDropdown: PopOut['hideDropdown']) => JSX.Element | React.ReactNode;
+    children: (closePopOut: () => void) => JSX.Element | React.ReactNode;
+    className?: string;
+    displayInline?: boolean;
     /**
      * The position where the content will try to fit
      */
@@ -27,6 +29,10 @@ export interface IPopOutProps {
      * Defaults to false
      */
     closeOnScroll?: boolean;
+    /**
+     * Delay the render of the info window after the trigger event has been fired
+     */
+    delayShow?: number;
     /**
      * Override the default PopOut container which is a Portal
      */
@@ -39,16 +45,15 @@ export interface IPopOutProps {
      * When the popout hides, fire this callback.
      */
     onClose?: () => void;
+    onMouseLeave?: React.MouseEventHandler<HTMLSpanElement>;
+    onMouseOver?: React.MouseEventHandler<HTMLSpanElement>;
+    preventShow?: boolean;
+    showArrow?: boolean;
+    triggerClassName?: string;
 }
 export interface IPopOutState {
     isOpen: boolean;
 }
-interface IEventHandlerItem {
-    register: boolean;
-    type: string;
-    method: EventListener;
-    options?: EventListenerOptions;
-}
 /**
  * The PopOut component displays/hides it's children when either the supplied trigger is clicked or if the openOnMount prop is supplied.
  * It should now be used in preference of InfoWindow where possible.
@@ -56,22 +61,4 @@ interface IEventHandlerItem {
  *
  * @requires PopOutBase
  */
-export declare class PopOut extends React.PureComponent<IPopOutProps, IPopOutState> {
-    private _contentRef;
-    private _triggerRef;
-    static defaultProps: {
-        usePortal: boolean;
-    };
-    constructor(props: IPopOutProps);
-    componentDidMount(): void;
-    componentWillUnmount(): void;
-    getEventHandlers: () => IEventHandlerItem[];
-    handleDocumentClick: (e: Event) => void;
-    addOptionalListeners: () => void;
-    removeOptionalListeners: () => void;
-    showDropdown: () => void;
-    hideDropdown: () => void;
-    triggerClick: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
-    render(): JSX.Element;
-}
-export {};
+export declare const PopOut: (props: IPopOutProps) => JSX.Element;

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

@@ -4,12 +4,16 @@ export interface IPopOutBase {
     /**
      * The element you are rendering the content from
      */
+    className?: string;
+    displayInline?: boolean;
     trigger: JSX.Element;
+    triggerClassName?: string;
     visible?: boolean;
     placement?: PopperJS.Options['placement'];
     modifiers?: PopperJS.Options['modifiers'];
     popOutContainer?: (PopperWrappedContent: JSX.Element) => JSX.Element;
     children?: React.ReactNode;
+    showArrow?: boolean;
 }
 /**
  * PopOutBase uses react-popper/popperjs under the hood and is a wrapper that sets up the Popperjs Manager, Reference and Popper.

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

@@ -0,0 +1,8 @@
+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;
+};
+export {};

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

@@ -1,21 +1,7 @@
 import * as React from 'react';
-import { IAnchorScores, ICursorOptions, ICursorPoints, Position as PositionType } from './info-window-utils';
-interface InfoWindowState {
-    closeInfoWindow: () => void;
-}
+import { IPopOutProps } from '../../popout/PopOut';
+import { ICursorOptions, Position } from './info-window-utils';
 export declare const InfoWindowContext: React.Context<InfoWindowState>;
-export declare type Position = PositionType;
-export declare type IEvent = 'click' | 'hover' | 'mount';
-export interface IInfoWindowStyles<T> {
-    triangleStyles: {
-        top: T;
-        left: T;
-    };
-    contentStyles: {
-        top: T;
-        left: T;
-    };
-}
 export interface IRequiredProps {
     /**
      * Content to be shown inside the info window
@@ -26,8 +12,10 @@ export interface IRequiredProps {
      */
     position: Position;
 }
-export declare type IInfoWindowProps = IRequiredProps & {
-    children?: React.ReactNode;
+export declare type IPopOutPropsSubset = IRequiredProps & Omit<IPopOutProps, 'children' | 'trigger' | 'showArrow'>;
+declare type IEvent = 'click' | 'mount' | 'hover';
+export declare type IInfoWindowPopOutProps = IPopOutPropsSubset & {
+    children: React.ReactNode;
     /**
      * IEvent type used to trigger the info window
      */
@@ -44,9 +32,6 @@ export declare type IInfoWindowProps = IRequiredProps & {
      * Prevent the display of the info window 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
@@ -58,103 +43,25 @@ export declare type IInfoWindowProps = IRequiredProps & {
     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;
+    triggerClassName?: string;
 };
-interface IState {
-    show: boolean;
-}
 /**
  *  The infowindow 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 InfoWindow extends React.PureComponent<IInfoWindowProps, IState> {
-    private _showDelayId;
-    private _triggerRef;
-    private _renderContainer;
-    private _contentRef;
-    private _triangleRef;
-    private _cursorPosition;
-    private _triggerRect;
-    constructor(props: IInfoWindowProps);
-    componentDidMount(): void;
-    componentDidUpdate(oldProps: IInfoWindowProps): 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: PositionType;
-    } | {
-        position: PositionType;
-        triangleStyles: {
-            top: string;
-            left: string;
-        } | {
-            top: string;
-            left: string;
-        };
-        contentStyles: {
-            top: string;
-            left: string;
-        } | {
-            top: string;
-            left: string;
-        };
-    };
-    removeRenderingContainer(): void;
-    createRenderContainer(): HTMLDivElement;
-    /**
-     * 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(): JSX.Element;
+export declare const InfoWindow: (props: IInfoWindowPopOutProps) => JSX.Element;
+interface InfoWindowState {
+    closeInfoWindow: () => void;
 }
 export declare const useInfoWindow: () => InfoWindowState;
 export {};

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

@@ -0,0 +1,154 @@
+import * as React from 'react';
+import { IAnchorScores, ICursorOptions, ICursorPoints, Position } from './info-window-utils';
+export declare type IEvent = 'click' | 'hover' | 'mount';
+export interface IInfoWindowStyles<T> {
+    triangleStyles: {
+        top: T;
+        left: T;
+    };
+    contentStyles: {
+        top: T;
+        left: T;
+    };
+}
+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: Position;
+}
+export declare type IInfoWindowProps = IRequiredProps & {
+    children?: React.ReactNode;
+    /**
+     * IEvent type used to trigger the info window
+     */
+    event?: IEvent;
+    /**
+     * Cursor options control what happens to the info window while moving the mouse within the trigger
+     */
+    cursorOption?: ICursorOptions;
+    /**
+     * Delay the render of the info window after the trigger event has been fired
+     */
+    delayShow?: number;
+    /**
+     * Prevent the display of the info window 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 infowindow 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<IInfoWindowProps, IState> {
+    private _showDelayId;
+    private _triggerRef;
+    private _renderContainer;
+    private _contentRef;
+    private _triangleRef;
+    private _cursorPosition;
+    private _triggerRect;
+    constructor(props: IInfoWindowProps);
+    componentDidMount(): void;
+    componentDidUpdate(oldProps: IInfoWindowProps): 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;
+    /**
+     * 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(): JSX.Element;
+}
+export {};

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

@@ -1,5 +1,6 @@
-import * as React from 'react';
-import { IInfoWindowProps, Position } from '../info-window/InfoWindow';
+/// <reference types="react" />
+import { IInfoWindowProps } 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';
@@ -8,19 +9,13 @@ export interface ITooltipProps extends IInfoWindowProps {
     /**
      * Colour scheme for the tooltip content.  Available options are 'dark' and 'light'
      */
+    delayShow?: IInfoWindowProps['delayShow'];
+    event?: IInfoWindowProps['event'];
     colorScheme?: IColorScheme;
     textAlignment?: IAlignStyle;
 }
 /**
- * Tooltips are an extened version of the info window that triggers on hover by default, delayed slightly and is styled with tooltip styles
+ * 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 class Tooltip extends React.PureComponent<ITooltipProps, {}> {
-    static defaultProps: {
-        event: string;
-        delayShow: number;
-        colorScheme: string;
-        textAlignment: string;
-    };
-    render(): JSX.Element;
-}
+export declare const Tooltip: (props: ITooltipProps) => JSX.Element;
 export {};

package/dist/hooks/useDebounce.d.ts

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

package/dist/index.d.ts

@@ -51,6 +51,7 @@ export * from './components/popout/PopOutBase';
 export * from './components/popout/PopOut';
 export * from './components/popups/info-window/InfoWindow';
 export * from './components/popups/overflow-tooltip/OverflowTooltip';
+export { LegacyInfoWindow } from './components/popups/info-window/LegacyInfoWindow';
 export * from './components/popups/tooltip/Tooltip';
 export * from './components/pill/Pill';
 export * from './components/table/Table';