@innovaccer/design-system 4.0.0 → 4.1.0

package/dist/core/components/atoms/dropdown/DropdownList.d.ts

@@ -0,0 +1,85 @@
+import * as React from 'react';
+import { PopoverProps } from "../../../index.type";
+import { TriggerProps } from "./DropdownButton";
+import { OptionRendererProps, OptionSchema } from "./option";
+import { BaseProps } from "../../../utils/types";
+import { ChangeEvent } from "../../../common.type";
+import { ErrorType } from "./Dropdown";
+export declare type DropdownAlign = 'left' | 'right';
+export declare type OptionType = 'DEFAULT' | 'WITH_ICON' | 'WITH_META' | 'ICON_WITH_META';
+export interface Selected {
+    label: OptionSchema['label'];
+    value: OptionSchema['value'];
+}
+export interface SelectAll {
+    indeterminate: boolean;
+    checked: boolean;
+}
+interface PopoverOptions {
+    appendToBody?: PopoverProps['appendToBody'];
+    hideOnReferenceEscape?: PopoverProps['hideOnReferenceEscape'];
+    boundaryElement?: PopoverProps['boundaryElement'];
+}
+declare type TriggerAndOptionProps = TriggerProps & OptionRendererProps;
+export interface ErrorTemplateProps {
+    errorType?: ErrorType;
+}
+export interface DropdownListProps extends TriggerAndOptionProps {
+    align?: DropdownAlign;
+    noResultMessage?: string;
+    errorTemplate?: React.FunctionComponent<ErrorTemplateProps>;
+    selectAllLabel?: string;
+    footerLabel?: string;
+    selectedSectionLabel?: string;
+    allItemsSectionLabel?: string;
+    applyButtonLabel?: string;
+    cancelButtonLabel?: string;
+    withSearch?: boolean;
+    withCheckbox?: boolean;
+    withSelectAll?: boolean;
+    showApplyButton?: boolean;
+    truncateOption?: boolean;
+    totalOptions?: number;
+    maxHeight?: number;
+    width?: number;
+    maxWidth?: number;
+    minWidth?: number;
+    loadersCount?: number;
+    popoverOptions?: PopoverOptions;
+    searchPlaceholder?: string;
+    scrollIndex?: number;
+}
+interface OptionsProps extends DropdownListProps, BaseProps {
+    listOptions: OptionSchema[];
+    searchTerm: string;
+    triggerLabel: string;
+    loadingOptions?: boolean;
+    searchInit?: boolean;
+    dropdownOpen?: boolean;
+    async?: boolean;
+    remainingOptions: number;
+    firstEnabledOption: number;
+    selected: OptionSchema[];
+    tempSelected: OptionSchema[];
+    previousSelected: OptionSchema[];
+    selectAll: SelectAll;
+    inputRef: React.RefObject<HTMLInputElement>;
+    customTrigger?: (label: string) => React.ReactElement;
+    applyOptions: () => void;
+    cancelOptions: () => void;
+    toggleDropdown: (open: boolean, type?: string) => void;
+    onClearOptions: () => void;
+    onSelectAll: (event: ChangeEvent) => void;
+    onSearchChange?: (searchText: string) => void;
+    onOptionSelect: (selected: any[] | any) => void;
+    onSelect: (option: OptionSchema, checked: boolean) => void;
+    updateOptions: () => void;
+    errorType: ErrorType;
+    errorTemplate?: React.FunctionComponent<ErrorTemplateProps>;
+}
+export declare const usePrevious: (value: any) => undefined;
+declare const DropdownList: {
+    (props: OptionsProps): React.JSX.Element;
+    displayName: string;
+};
+export default DropdownList;

package/dist/core/components/atoms/dropdown/ErrorTemplate.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { ErrorType } from "./Dropdown";
+interface ErrorTemplateProps {
+    dropdownStyle: React.CSSProperties;
+    errorType: ErrorType;
+    updateOptions: () => void;
+}
+export declare const ErrorTemplate: React.FC<ErrorTemplateProps>;
+export {};

package/dist/core/components/atoms/dropdown/Loading.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const Loading: (props: any) => React.JSX.Element | null;
+export default Loading;

package/dist/core/components/atoms/dropdown/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Dropdown";
+export * from "./Dropdown";

package/dist/core/components/atoms/dropdown/option/CheckboxOption.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { OptionTypeProps } from "./index";
+declare const CheckboxOption: (props: OptionTypeProps) => React.JSX.Element;
+export default CheckboxOption;

package/dist/core/components/atoms/dropdown/option/DefaultOption.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { OptionTypeProps } from "./index";
+declare const DefaultOption: (props: OptionTypeProps) => React.JSX.Element;
+export default DefaultOption;

package/dist/core/components/atoms/dropdown/option/IconOption.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { OptionTypeProps } from "./index";
+declare const IconOption: (props: OptionTypeProps) => React.JSX.Element;
+export default IconOption;

package/dist/core/components/atoms/dropdown/option/IconWithMetaOption.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { OptionTypeProps } from "./index";
+declare const IconWithMetaOption: (props: OptionTypeProps) => React.JSX.Element;
+export default IconWithMetaOption;

package/dist/core/components/atoms/dropdown/option/MetaOption.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { OptionTypeProps } from "./index";
+declare const MetaOption: (props: OptionTypeProps) => React.JSX.Element;
+export default MetaOption;

package/dist/core/components/atoms/dropdown/option/index.d.ts

@@ -0,0 +1,50 @@
+import * as React from 'react';
+import { MetaListProps, IconProps, TextProps } from "../../../../index.type";
+import { OptionType } from "../DropdownList";
+import { ChangeEvent, IconType } from "../../../../common.type";
+export declare type ClickEvent = React.MouseEvent<HTMLDivElement>;
+export interface OptionRendererProps {
+    optionRenderer?: (props: OptionProps) => React.ReactElement;
+    optionType?: OptionType;
+}
+export interface OptionSchema extends Record<string, any> {
+    label: string;
+    value: React.ReactText;
+    icon?: string;
+    subInfo?: string | MetaListProps;
+    optionType?: OptionType;
+    selected?: boolean;
+    disabled?: boolean;
+    group?: string;
+    iconType?: IconType;
+}
+export interface OptionTypeProps {
+    className: string;
+    textClassName: string;
+    dataTest?: string;
+    optionData: OptionSchema;
+    selected: boolean;
+    appearance?: IconProps['appearance'];
+    color?: TextProps['color'];
+    index: number;
+    onUpdateActiveOption: () => void;
+    onClickHandler?: (event: ClickEvent) => void;
+    onChangeHandler?: (event: ChangeEvent) => void;
+    renderSubInfo: (subInfo: string | MetaListProps) => React.ReactElement;
+    id?: string;
+}
+interface OptionProps extends OptionRendererProps {
+    optionData: OptionSchema;
+    selected: boolean;
+    truncateOption?: boolean;
+    checkboxes?: boolean;
+    index: number;
+    active?: boolean;
+    menu?: boolean;
+    onClick?: () => void;
+    onChange?: (event: ChangeEvent) => void;
+    updateActiveOption?: (index: number) => void;
+    id?: string;
+}
+declare const Option: (props: OptionProps) => React.JSX.Element;
+export default Option;

package/dist/core/components/atoms/dropdown/utility.d.ts

@@ -0,0 +1,15 @@
+import { OptionSchema as Option } from "./option";
+export declare const getSearchedOptions: (options: any, searchTerm: string) => any;
+export declare const _isEqual: (firstList: Option[], secondList: Option[]) => boolean;
+export declare const _isControlled: (selected?: Option[] | undefined) => boolean;
+export declare const _isOpenControlled: (open?: boolean | undefined) => boolean;
+export declare const _showSelectedItems: (bulk: boolean, searchTerm: string, withCheckbox?: boolean | undefined) => boolean | undefined;
+export declare const _isSelectAllPresent: (searchTerm: string, bulkOptions: number, withSelectAll: boolean, withCheckbox?: boolean | undefined) => boolean | undefined;
+export declare const scrollTo: (element: Element, top: number) => void;
+export declare const scrollIntoView: (menuElement: HTMLDivElement | null, focusedElement: HTMLElement) => void;
+export declare const getSelectAll: (selected: Option[], optionsLength: number, disabledOptionsLength: number) => {
+    indeterminate: boolean;
+    checked: boolean;
+};
+export declare const scrollToOptionIndex: (scrollIndex: number, listOptions: any) => void;
+export declare const groupListOptions: (listOptions: Option[]) => Option[];

package/dist/core/components/atoms/editable/Editable.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { BaseProps } from "../../../utils/types";
+export interface EditableProps extends BaseProps {
+    editing?: boolean;
+    children: React.ReactNode;
+    onChange: (eventType: string) => void;
+}
+export declare const Editable: {
+    (props: EditableProps): React.JSX.Element;
+    displayName: string;
+};
+export default Editable;

package/dist/core/components/atoms/editable/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Editable";
+export * from "./Editable";

package/dist/core/components/atoms/heading/Heading.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { BaseHtmlProps, BaseProps } from "../../../utils/types";
+import { HeadingAppearance, TextColor } from "../../../common.type";
+export declare type HeadingSize = 's' | 'm' | 'l' | 'xl' | 'xxl';
+export interface HeadingProps extends BaseProps, BaseHtmlProps<HTMLHeadingElement> {
+    children: React.ReactText;
+    appearance: HeadingAppearance;
+    size: HeadingSize;
+    color?: TextColor;
+}
+export declare const Heading: {
+    (props: HeadingProps): React.JSX.Element;
+    displayName: string;
+    defaultProps: {
+        appearance: string;
+        size: string;
+    };
+};
+export default Heading;

package/dist/core/components/atoms/heading/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Heading";
+export * from "./Heading";

package/dist/core/components/atoms/helpText/HelpText.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { BaseProps } from "../../../utils/types";
+export interface HelpTextProps extends BaseProps {
+    message?: string;
+    error?: boolean;
+}
+export declare const HelpText: {
+    (props: HelpTextProps): React.JSX.Element | null;
+    displayName: string;
+};
+export default HelpText;

package/dist/core/components/atoms/helpText/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./HelpText";
+export * from "./HelpText";

package/dist/core/components/atoms/icon/Icon.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { BaseProps } from "../../../utils/types";
+export declare type IconAppearance = 'default' | 'destructive' | 'white' | 'subtle' | 'disabled' | 'info' | 'alert' | 'warning' | 'success' | 'primary_lighter' | 'primary' | 'primary_dark' | 'primary_darker' | 'alert_lighter' | 'alert_dark' | 'alert_darker' | 'warning_lighter' | 'warning_dark' | 'warning_darker' | 'success_lighter' | 'success_dark' | 'success_darker' | 'accent1' | 'accent1_lighter' | 'accent1_dark' | 'accent1_darker' | 'accent2' | 'accent2_lighter' | 'accent2_dark' | 'accent2_darker' | 'accent3' | 'accent3_lighter' | 'accent3_dark' | 'accent3_darker' | 'accent4' | 'accent4_lighter' | 'accent4_dark' | 'accent4_darker' | 'inverse';
+export declare type IconType = 'filled' | 'outlined' | 'outline' | 'rounded' | 'round' | 'two-tone' | 'sharp';
+export interface IconProps extends BaseProps {
+    name?: string;
+    size: number;
+    type?: IconType;
+    appearance?: IconAppearance;
+    onClick?: (e: React.MouseEvent<HTMLElement>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLElement>) => void;
+    children?: React.ReactNode;
+    tabIndex?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>['tabIndex'];
+}
+export declare const Icon: {
+    (props: IconProps): React.JSX.Element;
+    displayName: string;
+    defaultProps: {
+        size: number;
+    };
+};
+export default Icon;

package/dist/core/components/atoms/icon/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Icon";
+export * from "./Icon";

package/dist/core/components/atoms/input/Input.d.ts

@@ -0,0 +1,49 @@
+import * as React from 'react';
+import { IconProps } from "../../../index.type";
+import { BaseHtmlProps, BaseProps } from "../../../utils/types";
+import { AutoComplete, IconType } from "../../../common.type";
+export declare type InputType = 'text' | 'password' | 'number' | 'email' | 'tel' | 'url';
+export declare type InputSize = 'tiny' | 'regular' | 'large';
+export interface InputProps extends BaseProps, BaseHtmlProps<HTMLInputElement> {
+    name?: string;
+    type?: InputType;
+    value?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    size?: InputSize;
+    icon?: string;
+    iconType?: IconType;
+    inlineLabel?: string;
+    disabled?: boolean;
+    required?: boolean;
+    autoFocus?: boolean;
+    autoComplete?: AutoComplete;
+    readOnly?: boolean;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    error?: boolean;
+    info?: string;
+    minWidth?: string;
+    onClear?: (e: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onClick?: (e: React.MouseEvent<HTMLInputElement>) => void;
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onPaste?: React.ClipboardEventHandler<HTMLInputElement>;
+    actionIcon?: React.ReactElement<IconProps>;
+}
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+declare const ActionInput: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>> & {
+    ActionButton: {
+        (props: import("./actionButton").ActionButtonProps): React.JSX.Element;
+        displayName: string;
+        defaultProps: {
+            size: number;
+            type: string;
+        };
+    };
+};
+export default ActionInput;

package/dist/core/components/atoms/input/actionButton/ActionButton.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { BaseProps } from "../../../../utils/types";
+import { IconType } from "../../../../common.type";
+export declare type ActionButtonType = 'outlined' | 'rounded';
+export interface ActionButtonProps extends BaseProps {
+    name?: string;
+    size: number;
+    type?: ActionButtonType;
+    iconType?: IconType;
+    onClick?: (e: React.MouseEvent<HTMLElement>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLElement>) => void;
+    children?: React.ReactNode;
+    tabIndex?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>['tabIndex'];
+}
+export declare const ActionButton: {
+    (props: ActionButtonProps): React.JSX.Element;
+    displayName: string;
+    defaultProps: {
+        size: number;
+        type: string;
+    };
+};
+export default ActionButton;

package/dist/core/components/atoms/input/actionButton/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./ActionButton";
+export * from "./ActionButton";

package/dist/core/components/atoms/input/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Input";
+export * from "./Input";

package/dist/core/components/atoms/label/Label.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { BaseHtmlProps, BaseProps } from "../../../utils/types";
+export interface LabelProps extends BaseProps, BaseHtmlProps<HTMLLabelElement> {
+    children: React.ReactNode;
+    disabled?: boolean;
+    required?: boolean;
+    optional?: boolean;
+    withInput?: boolean;
+    info?: string;
+}
+export declare const Label: {
+    (props: LabelProps): React.JSX.Element;
+    displayName: string;
+};
+export default Label;

package/dist/core/components/atoms/label/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Label";
+export * from "./Label";

package/dist/core/components/atoms/legend/Legend.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { TextAppearance } from "../text";
+import { BaseProps } from "../../../utils/types";
+export interface LegendProps extends BaseProps {
+    children: React.ReactText;
+    iconAppearance: string;
+    labelAppearance?: TextAppearance;
+    iconSize: number;
+    labelWeight?: 'strong' | 'medium';
+    onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseEnter?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseLeave?: (e: React.MouseEvent<HTMLDivElement>) => void;
+}
+export declare const Legend: {
+    (props: LegendProps): React.JSX.Element;
+    displayName: string;
+    defaultProps: {
+        iconAppearance: string;
+        iconSize: number;
+    };
+};
+export default Legend;

package/dist/core/components/atoms/legend/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Legend";
+export * from "./Legend";

package/dist/core/components/atoms/link/Link.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { BaseProps, OmitNativeProps } from "../../../utils/types";
+declare type LinkTarget = '_blank' | '_self' | '_parent' | '_top';
+declare type LinkAppearance = 'default' | 'subtle';
+declare type LinkSize = 'regular' | 'tiny';
+export interface LinkProps extends BaseProps, OmitNativeProps<HTMLLinkElement, 'onClick'> {
+    id?: string;
+    appearance: LinkAppearance;
+    size: LinkSize;
+    disabled: boolean;
+    href?: string;
+    target?: LinkTarget;
+    rel?: string;
+    download?: string;
+    hreflang?: string;
+    onClick?: (event: React.MouseEvent<HTMLAnchorElement>) => void;
+    children: React.ReactNode;
+}
+export declare const Link: {
+    (props: LinkProps): React.JSX.Element;
+    displayName: string;
+    defaultProps: {
+        appearance: string;
+        size: string;
+        disabled: boolean;
+    };
+};
+export default Link;

package/dist/core/components/atoms/link/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Link";
+export * from "./Link";

package/dist/core/components/atoms/linkButton/LinkButton.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { BaseProps, BaseHtmlProps } from "../../../utils/types";
+import { IconType } from "../../../common.type";
+export declare type ButtonType = 'button' | 'submit' | 'reset';
+export declare type LinkButtonSize = 'tiny' | 'regular';
+export declare type IconAlignment = 'left' | 'right';
+export interface LinkButtonProps extends BaseProps, BaseHtmlProps<HTMLButtonElement> {
+    type?: ButtonType;
+    size?: LinkButtonSize;
+    disabled?: boolean;
+    icon?: string;
+    iconAlign?: IconAlignment;
+    iconType?: IconType;
+    children: React.ReactText;
+    tabIndex?: number;
+    autoFocus?: boolean;
+    subtle?: boolean;
+    onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    onMouseEnter?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    onMouseLeave?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+}
+export declare const LinkButton: React.ForwardRefExoticComponent<LinkButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export default LinkButton;

package/dist/core/components/atoms/linkButton/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./LinkButton";
+export * from "./LinkButton";

package/dist/core/components/atoms/message/Message.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { BaseProps } from "../../../utils/types";
+import { MessageAppearance } from "../../../common.type";
+export interface MessageProps extends BaseProps {
+    appearance: MessageAppearance;
+    title?: string;
+    children?: React.ReactNode;
+    description: string;
+    actions?: React.ReactNode;
+}
+export declare const Message: {
+    (props: MessageProps): React.JSX.Element;
+    displayName: string;
+    defaultProps: {
+        appearance: string;
+        description: string;
+    };
+};
+export default Message;

package/dist/core/components/atoms/message/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Message";
+export * from "./Message";

package/dist/core/components/atoms/metaList/Meta.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { MetaSize } from "./MetaList";
+import { IconType } from "../../../common.type";
+export interface MetaProps {
+    label: string;
+    icon?: string;
+    size?: MetaSize;
+    iconType?: IconType;
+}
+export declare const Meta: {
+    (props: MetaProps): React.JSX.Element;
+    displayName: string;
+};
+export default Meta;

package/dist/core/components/atoms/metaList/MetaList.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { MetaProps } from "./Meta";
+import { IconProps, TextProps } from "../../../index.type";
+import { BaseProps } from "../../../utils/types";
+export declare type MetaSize = 'small' | 'regular';
+export interface MetaListProps extends BaseProps {
+    list: MetaProps[];
+    seperator?: boolean;
+    seperatorAppearance: IconProps['appearance'];
+    iconAppearance: IconProps['appearance'];
+    labelAppearance: TextProps['appearance'];
+    size?: MetaSize;
+}
+export declare const MetaList: {
+    (props: MetaListProps): React.JSX.Element;
+    displayName: string;
+    defaultProps: {
+        seperatorAppearance: string;
+        iconAppearance: string;
+        labelAppearance: string;
+        size: string;
+    };
+};
+export default MetaList;

package/dist/core/components/atoms/metaList/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./MetaList";
+export * from "./MetaList";

package/dist/core/components/atoms/metricInput/MetricInput.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { BaseHtmlProps, BaseProps } from "../../../utils/types";
+import { AutoComplete, IconType } from "../../../common.type";
+export declare type MetricInputSize = 'regular' | 'large';
+export interface MetricInputProps extends BaseProps, BaseHtmlProps<HTMLInputElement> {
+    name?: string;
+    value?: React.ReactText;
+    defaultValue?: React.ReactText;
+    placeholder?: string;
+    size?: MetricInputSize;
+    icon?: string;
+    iconType?: IconType;
+    prefix?: string;
+    suffix?: string;
+    disabled?: boolean;
+    autoFocus?: boolean;
+    autoComplete?: AutoComplete;
+    readOnly?: boolean;
+    min?: number;
+    max?: number;
+    error?: boolean;
+    showActionButton?: boolean;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onClick?: (e: React.MouseEvent<HTMLInputElement>) => void;
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+}
+export declare const MetricInput: React.ForwardRefExoticComponent<MetricInputProps & React.RefAttributes<HTMLInputElement>>;
+export default MetricInput;

package/dist/core/components/atoms/metricInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./MetricInput";
+export * from "./MetricInput";

package/dist/core/components/atoms/multiSlider/Handle.d.ts

@@ -0,0 +1,52 @@
+import * as React from 'react';
+export interface HandleProps {
+    value: number;
+    fillAfter?: boolean;
+    fillBefore?: boolean;
+    onChange?: (newValue: number) => void;
+    onRelease?: (newValue: number) => void;
+}
+export interface InternalHandleProps extends HandleProps {
+    disabled?: boolean;
+    isCurrentLabelHovered?: boolean;
+    label: string;
+    max: number;
+    min: number;
+    stepSize: number;
+    tickSize: number;
+    tickSizeRatio: number;
+    zIndex?: number;
+}
+export interface HandleState {
+    isHandleMoving?: boolean;
+    isHandleHovered?: boolean;
+}
+export declare class Handle extends React.Component<InternalHandleProps, HandleState> {
+    state: {
+        isHandleMoving: boolean;
+        isHandleHovered: boolean;
+    };
+    handleElement: HTMLElement | null;
+    refHandlers: {
+        handle: (el: HTMLDivElement) => HTMLDivElement;
+    };
+    componentWillUnmount(): void;
+    componentDidUpdate(_prevProps: InternalHandleProps, prevState: HandleState): void;
+    mouseEventClientOffset: (event: MouseEvent | React.MouseEvent<HTMLElement>) => number;
+    clientToValue: (clientPixel: number) => number;
+    changeValue: (newValue: number, callback?: ((newValue: number) => void) | undefined) => number;
+    endHandleMovement: (event: MouseEvent) => void;
+    continueHandleMovement: (event: MouseEvent) => void;
+    beginHandleMovement: (event: MouseEvent | React.MouseEvent<HTMLElement>) => void;
+    handleKeyDown: (event: React.KeyboardEvent<HTMLSpanElement>) => void;
+    handleKeyUp: (event: React.KeyboardEvent<HTMLSpanElement>) => void;
+    getHandleMidpointAndOffset: (handleElement: HTMLElement | null, useOppositeDimension?: boolean) => {
+        handleMidpoint: number;
+        handleOffset: number;
+    };
+    handleMouseOver: () => void;
+    handleMouseLeave: () => void;
+    render(): React.JSX.Element;
+    removeDocumentEventListeners: () => void;
+}
+export default Handle;

package/dist/core/components/atoms/multiSlider/SliderUtils.d.ts

@@ -0,0 +1,8 @@
+export declare const formatPercentage: (ratio: number) => string;
+export declare const countDecimalPlaces: (value: number) => number;
+export declare const approxEqual: (a: number, b: number) => boolean;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const arraysEqual: (oldValues: number[], newValues: number[]) => boolean | undefined;
+export declare function argMin<T>(values: T[], argFn: (value: T) => any): T | undefined;
+export declare function fillValues<T>(values: T[], startIndex: number, endIndex: number, fillValue: T): void;
+export declare function isElementOfType(element: React.ReactElement): boolean;