@skedulo/sked-ui 0.0.0-preview-react-18

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) => JSX.Element;

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

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

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

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

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

@@ -0,0 +1,160 @@
+import * as React from 'react';
+import { IAnchorScores, ICursorOptions, ICursorPoints, Position as PositionType } from './info-window-utils';
+interface InfoWindowState {
+    closeInfoWindow: () => void;
+}
+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
+     */
+    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 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 useInfoWindow: () => InfoWindowState;
+export {};

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

@@ -0,0 +1,84 @@
+import * as React from 'react';
+import { ICursorOptions, Position as PositionType } from './info-window-utils';
+declare type Position = PositionType;
+declare type IEvent = 'click' | 'hover' | 'mount';
+export interface IPopOutRequiredProps {
+    /**
+     * 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 IInfoWindowPopOutProps = IPopOutRequiredProps & {
+    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;
+};
+/**
+ *  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 const UnmemoizedInfoWindowPopOut: (props: IInfoWindowPopOutProps) => JSX.Element;
+export declare const InfoWindowPopOut: React.MemoExoticComponent<(props: IInfoWindowPopOutProps) => JSX.Element>;
+export {};

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

@@ -0,0 +1,159 @@
+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;
+    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;
+    /**
+     * 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 InfoWindowContext: React.Context<InfoWindowState>;
+interface InfoWindowState {
+    closeInfoWindow: () => void;
+}
+export declare const useLegacyInfoWindow: () => InfoWindowState;
+export {};

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

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ModalProps {
+    children?: React.ReactNode;
+}
+export declare const PortalWrapper: ({ children }: ModalProps) => React.ReactPortal;
+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/useClickAway.d.ts

@@ -0,0 +1,25 @@
+import { RefObject } from 'react';
+/**
+ * Triggers callback when user clicks outside target area.
+ * https://github.com/streamich/react-use/blob/master/src/useClickAway.ts
+ *
+ * Usage:
+ *
+ * const Demo = () => {
+ *   const ref = useRef<HTMLDivElement>(null)
+ *
+ *   useClickAway(ref, () => {
+ *     console.log('OUTSIDE CLICKED')
+ *   })
+ *
+ *   return <div ref={ref}>Content</div>
+ * }
+ *
+ * Reference:
+ *
+ * useClickAway(ref, onMouseEvent)
+ * useClickAway(ref, onMouseEvent, ['click'])
+ * useClickAway(ref, onMouseEvent, ['mousedown', 'touchstart'])
+ *
+ */
+export declare const useClickAway: <E extends Event = Event>(ref: RefObject<HTMLElement | null>, onClickAway: (event: E) => void, events?: string[]) => void;

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,30 @@
+import * as React from 'react';
+import { ITooltipPosition, ITooltipProps } from '../tooltip/Tooltip';
+export interface IOverflowTooltipProps extends Pick<ITooltipProps, 'dataAttributes'> {
+    /** 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> {
+    static defaultProps: {
+        position: string;
+    };
+    _element: HTMLDivElement;
+    constructor(props: IOverflowTooltipProps);
+    componentDidMount(): void;
+    refElement: (element: HTMLDivElement) => void;
+    checkOverflow: () => void;
+    isTextOverflow(): boolean;
+    render(): JSX.Element;
+}