@fattureincloud/fic-design-system 0.14.4 → 0.15.0

package/dist/components/newTable_v2/constants.d.ts

@@ -0,0 +1,9 @@
+import { SettingsLabels, TableComponent } from './types';
+export declare const HEIGHT_SMALL = 42;
+export declare const HEIGHT_LARGE = 56;
+export declare const TEXTAREA_HEIGHT = 100;
+export declare const CHECKBOX_WIDTH = 35;
+export declare const CLASS_PREFIX = "DS-table";
+export declare const DS_PREFIX = "dstbl";
+export declare const COMPONENTS: Record<TableComponent, string[]>;
+export declare const defaultLabels: Required<SettingsLabels>;

package/dist/components/newTable_v2/customCells/BooleanCell.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare type BooleanCellProps = {
+    value: boolean;
+};
+declare const BooleanCell: ({ value }: BooleanCellProps) => JSX.Element;
+export default BooleanCell;

package/dist/components/newTable_v2/customCells/DateCell.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ParsableDateTime, ValidFormat } from '@fattureincloud/madbit-js-dates';
+declare type Props = {
+    date: ParsableDateTime;
+    format: ValidFormat;
+    locale: 'en' | 'es' | 'it';
+};
+declare const DateCell: (props: Props) => JSX.Element;
+export default DateCell;

package/dist/components/newTable_v2/customCells/MicroTagCell.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { MicroTagProps } from '../../microTag';
+declare type ConversionFnProps<T> = {
+    row: Row<T>;
+    convertToProps: (row: Row<T>) => MicroTagProps;
+};
+declare type Props<T> = MicroTagProps | ConversionFnProps<T>;
+declare const MicroTagCell: <T>(props: Props<T>) => JSX.Element;
+export default MicroTagCell;

package/dist/components/newTable_v2/customCells/TagCell.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { TagProps } from '../../tag';
+declare type ConversionFnProps<T> = {
+    row: Row<T>;
+    convertToProps: (row: Row<T>) => TagProps;
+};
+declare type Props<T> = TagProps | ConversionFnProps<T>;
+declare const TagCell: <T>(props: Props<T>) => JSX.Element;
+export default TagCell;

package/dist/components/newTable_v2/customCells/TwoRowsCell.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { IconProps } from '../../icon';
+declare type Props = {
+    icon?: IconProps;
+    mainText?: string;
+    subText?: string;
+};
+declare const NameVatTableCell: ({ icon, mainText, subText }: Props) => JSX.Element;
+export default NameVatTableCell;

package/dist/components/newTable_v2/customCells/ValueWithUnitCell.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { UnitConfig } from '../../../common/utils/stringUtils';
+import { CellValue } from '../types';
+declare type Props = {
+    value: CellValue;
+    unit: UnitConfig;
+};
+declare const ValueWithUnitCell: ({ unit, value }: Props) => JSX.Element;
+export default ValueWithUnitCell;

package/dist/components/newTable_v2/customCells/index.d.ts

@@ -0,0 +1,4 @@
+export { default as DateCell } from './DateCell';
+export { default as MicroTagCell } from './MicroTagCell';
+export { default as TagCell } from './TagCell';
+export { default as ValueWithUnitCell } from './ValueWithUnitCell';

package/dist/components/newTable_v2/hooks/useClassNames.d.ts

@@ -0,0 +1,6 @@
+import { TableComponent } from '../types';
+declare type ClassNames<K extends TableComponent> = {
+    [P in K as `${P}ClassName`]: string;
+};
+declare const useClassNames: <K extends TableComponent>(...components: K[]) => ClassNames<K>;
+export default useClassNames;

package/dist/components/newTable_v2/hooks/useColumnHelper.d.ts

@@ -0,0 +1,7 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { CellValue, ColumnsType } from '../types';
+declare type ColumnsHelperProps<T> = {
+    columns: ColumnsType<T>[];
+};
+declare const useColumnsHelper: <T>({ columns }: ColumnsHelperProps<T>) => ColumnDef<T, CellValue>[];
+export default useColumnsHelper;

package/dist/components/newTable_v2/hooks/useColumnPinning.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ColumnPinningState } from '@tanstack/react-table';
+interface ReturnType {
+    readonly columnPinning: ColumnPinningState;
+    readonly setColumnPinning: React.Dispatch<React.SetStateAction<ColumnPinningState>>;
+}
+export declare const useColumnPinning: (defaultValues?: ColumnPinningState | undefined) => ReturnType;
+export {};

package/dist/components/newTable_v2/hooks/usePagination.d.ts

@@ -0,0 +1,8 @@
+import { PaginationState } from '@tanstack/react-table';
+import { Dispatch, SetStateAction } from 'react';
+interface ReturnType {
+    pagination: PaginationState;
+    setPagination: Dispatch<SetStateAction<PaginationState>>;
+}
+export declare const usePagination: (size: number | undefined) => ReturnType;
+export {};

package/dist/components/newTable_v2/index.d.ts

@@ -0,0 +1,3 @@
+export { default as NewTable } from './Table';
+export * from './types';
+export * from './customCells';

package/dist/components/newTable_v2/providers/TableProvider/TableProvider.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { TableContextProps, TableProviderProps } from './types';
+export declare const TableContext: React.Context<TableContextProps>;
+declare const TableProvider: <T>({ absoluteElementsPortal, actionColumnWidth, children, columns, columnsSettings: initialColumnsSettings, enableSettings, hideableColumns, isLoading, isSelectable, loadingStyle, onSettingsChange, rowActions, rowSize: initialRowSize, settingsLabels, settingsTooltip, sortableColumns, }: TableProviderProps<T>) => JSX.Element;
+export default TableProvider;

package/dist/components/newTable_v2/providers/TableProvider/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TableProvider } from './TableProvider';
+export { TableContext } from './TableProvider';
+export { TableContextProps, TableProviderProps } from './types';

package/dist/components/newTable_v2/providers/TableProvider/types.d.ts

@@ -0,0 +1,27 @@
+import { Dispatch, ReactNode, SetStateAction } from 'react';
+import { TooltipProps } from '../../../tooltip';
+import { ColumnsSettings, LoadingStyle, RowSize, SettingsLabels, TableProps, TableSettings } from '../../types';
+export declare type ImmutableContext = {
+    absoluteElementsPortal?: HTMLElement;
+    loadingStyle?: LoadingStyle;
+    tableID: string;
+    enableSettings: boolean;
+    hideableColumns: string[];
+    settingsLabels: Required<SettingsLabels>;
+    settingsTooltip: TooltipProps;
+    sortableColumns: string[];
+};
+export declare type TableContextProps = ImmutableContext & {
+    actionColumnWidth: number;
+    hasActions: boolean;
+    hasCheckbox: boolean;
+    isLoading: boolean;
+    rowSize: RowSize;
+    setRowSize: Dispatch<SetStateAction<RowSize>>;
+    columnsSettings: Required<ColumnsSettings>;
+    setColumnsSettings: Dispatch<SetStateAction<Required<ColumnsSettings>>>;
+    onSettingsChange?: TableSettings['onSettingsChange'];
+};
+export declare type TableProviderProps<T> = TableProps<T> & {
+    children: ReactNode | ReactNode[];
+};

package/dist/components/newTable_v2/stories/actions.d.ts

@@ -0,0 +1,5 @@
+import { BulkAction, RowActions } from '../types';
+import { DataType } from './types';
+export declare const rowActions: RowActions<DataType>;
+export declare const rowActionsAlternative: RowActions<DataType>;
+export declare const bulkActions: BulkAction[];

package/dist/components/newTable_v2/stories/columns.d.ts

@@ -0,0 +1,3 @@
+import { ColumnsType } from '../types';
+import { DataType } from './types';
+export declare const columns: ColumnsType<DataType>[];

package/dist/components/newTable_v2/stories/data.d.ts

@@ -0,0 +1,2 @@
+import { DataType } from './types';
+export declare const data: DataType[];

package/dist/components/newTable_v2/stories/styled.d.ts

@@ -0,0 +1 @@
+export declare const TableWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/dist/components/newTable_v2/stories/types.d.ts

@@ -0,0 +1,10 @@
+import { CellValue } from '../types';
+export interface DataType {
+    id: string;
+    rowStatus?: 'highlighted';
+    supplier: CellValue;
+    description: CellValue;
+    payment: CellValue;
+    amount: CellValue;
+    date: CellValue;
+}

package/dist/components/newTable_v2/styled.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare const Container: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const HorizontalScroll: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const DSTable: import("styled-components").StyledComponent<"table", import("styled-components").DefaultTheme, {}, never>;
+export declare const SortIndicator: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const PaginationContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

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

@@ -0,0 +1,6 @@
+import { Meta, Story } from '@storybook/react';
+import { DataType } from './stories/types';
+import { TableProps } from './types';
+export declare const Template: Story<TableProps<DataType>>;
+declare const TableStories: Meta<TableProps<DataType>>;
+export default TableStories;

package/dist/components/newTable_v2/types/cellsTypes.d.ts

@@ -0,0 +1 @@
+export declare type CellValue = Record<string, unknown> | boolean | string | number | null | undefined;

package/dist/components/newTable_v2/types/columnsTypes.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="react" />
+import { DisplayColumnDef as RTDisplayColumnDef, GroupColumnDef as RTGroupColumnDef, IdentifiedColumnDef, Row } from '@tanstack/react-table';
+import { InputTextProps } from '../../form/inputText';
+import { TooltipProps } from '../../tooltip';
+import { CellValue } from './cellsTypes';
+import { ColumnDefType } from './enums';
+export declare type BaseColumnsType<T> = {
+    columnDef: BaseColumnDef<T>;
+    columnDefType: ColumnDefType;
+    key: keyof T & string;
+};
+export declare type BaseColumnDef<T> = IdentifiedColumnDef<T> & {
+    align?: 'center' | 'left' | 'right';
+    customCell?: (row: Row<T>, hasHover: boolean) => JSX.Element;
+    disableClick?: boolean;
+    header?: IdentifiedColumnDef<T, CellValue>['header'] | JSX.Element;
+    headerTooltip?: TooltipProps;
+    id?: string;
+    maxWidth?: number;
+    minWidth?: number;
+    multiline?: boolean;
+};
+export declare type EditableCellsColumn<T> = {
+    inputProps?: Omit<InputTextProps, 'value' | 'setValue'>;
+    onChange: (text: string, row: Row<T>) => void;
+};
+declare type StandardCellsColumn = {
+    inputProps?: never;
+    onChange?: never;
+};
+export declare type AccessorColumnDef<T> = IdentifiedColumnDef<T, CellValue> & BaseColumnDef<T> & (EditableCellsColumn<T> | StandardCellsColumn);
+export declare type AccessorColumn<T> = BaseColumnsType<T> & {
+    columnDefType: ColumnDefType.ACCESSOR;
+    columnDef: AccessorColumnDef<T>;
+};
+export declare type DisplayColumnDef<T> = RTDisplayColumnDef<T, CellValue> & BaseColumnDef<T>;
+export declare type DisplayColumn<T> = BaseColumnsType<T> & {
+    columnDefType: ColumnDefType.DISPLAY;
+    columnDef: DisplayColumnDef<T> & BaseColumnDef<T>;
+};
+export declare type GroupColumnDef<T> = RTGroupColumnDef<T, CellValue>;
+export declare type GroupColumn<T> = BaseColumnsType<T> & {
+    columnDefType: ColumnDefType.GROUP;
+    columnDef: GroupColumnDef<T>;
+};
+export declare type ColumnDef<T> = AccessorColumnDef<T> | DisplayColumnDef<T> | GroupColumnDef<T>;
+export declare type ColumnsType<T> = AccessorColumn<T> | DisplayColumn<T> | GroupColumn<T>;
+export {};

package/dist/components/newTable_v2/types/enums.d.ts

@@ -0,0 +1,16 @@
+export declare enum RowSize {
+    SMALL,
+    LARGE
+}
+export declare enum ColumnDefType {
+    ACCESSOR = "accessor",
+    DISPLAY = "display",
+    GROUP = "group",
+    ACTION = "action"
+}
+export declare enum ActionType {
+    CHECKBOX = "checkbox",
+    TOGGLE = "toggle",
+    ROW_ACTIONS = "row_actions",
+    SETTINGS = "settings"
+}

package/dist/components/newTable_v2/types/features/actions.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { RequireAtLeastOne } from '../../../../common/types';
+import { ButtonProps } from '../../../buttons';
+import { buttonColors } from '../../../buttons/button/types';
+import { DropdownItemProps } from '../../../dropdown';
+import { IconProps } from '../../../icon';
+import { TooltipProps } from '../../../tooltip';
+export declare type TableActions<T> = {
+    actionsHeader?: string | JSX.Element;
+    rowActions?: RowActions<T> | ((row: Row<T>) => RowActions<T>);
+    bulkActions?: BulkAction[];
+    renderBulkActions?: (rows: string[]) => JSX.Element;
+};
+export interface RowActions<T> {
+    primary?: PrimaryAction<T>[];
+    dropdown?: DropdownActions<T>;
+}
+declare type BaseAction = {
+    icon?: IconProps;
+    text?: string;
+};
+export declare type PrimaryAction<T> = RequireAtLeastOne<BaseAction> & {
+    className?: string;
+    color?: buttonColors;
+    onClick: (row: Row<T>) => void;
+    tooltip?: TooltipProps;
+};
+export declare type TableActionsDropdowItem<T> = DropdownItemProps & {
+    onClick: (row: Row<T>) => void;
+};
+export declare type DropdownActions<T> = {
+    items: TableActionsDropdowItem<T>[];
+    tooltip?: TooltipProps;
+};
+export interface BulkAction extends Omit<ButtonProps, 'onClick' | 'text'> {
+    onClick: (rows: string[]) => void;
+    text: string | JSX.Element;
+}
+export {};

package/dist/components/newTable_v2/types/features/highlight.d.ts

@@ -0,0 +1,5 @@
+import { Row } from '@tanstack/react-table';
+export declare type HighlightRow<T> = {
+    isRowHighlighted?: (row: Row<T>) => boolean;
+    rowHighlightColor?: string;
+};

package/dist/components/newTable_v2/types/features/pagination.d.ts

@@ -0,0 +1,20 @@
+import { PaginationState } from '@tanstack/react-table';
+export declare type PaginatedTable = {
+    noPagination?: false;
+    pageSize: number;
+    listSize: number;
+    paginationPreviousText?: string;
+    paginationNextText?: string;
+    onPaginationChange: (pagination: PaginationState) => void;
+    totalPages: number;
+    resetPageIndex?: boolean;
+} | {
+    noPagination: true;
+    pageSize?: never;
+    listSize?: never;
+    paginationPreviousText?: never;
+    paginationNextText?: never;
+    onPaginationChange?: never;
+    totalPages?: never;
+    resetPageIndex?: never;
+};

package/dist/components/newTable_v2/types/features/selectRow.d.ts

@@ -0,0 +1,16 @@
+export declare type AllSelectedCTA = {
+    description?: string;
+    onClick: () => void;
+    text: string;
+};
+export declare type SelectableTable = {
+    isSelectable: true;
+    rowSelection: string[];
+    onRowSelection: (e: string[]) => void;
+    allSelectedCTA?: AllSelectedCTA;
+} | {
+    isSelectable?: false;
+    rowSelection?: never;
+    onRowSelection?: never;
+    allSelectedCTA?: never;
+};

package/dist/components/newTable_v2/types/features/settings.d.ts

@@ -0,0 +1,27 @@
+import { VisibilityState } from '@tanstack/react-table';
+import { TooltipProps } from '../../../tooltip';
+import { RowSize } from '../enums';
+export declare type ColumnsSettings = {
+    order?: string[];
+    visible?: VisibilityState;
+};
+export declare type VariableSettings = {
+    rowSize?: RowSize;
+    columnsSettings?: ColumnsSettings;
+};
+export declare type SettingsLabels = {
+    main?: string;
+    rowSizeLabel?: string;
+    rowSizeSmallLabel?: string;
+    rowSizeLargeLabel?: string;
+    columnsLabel?: string;
+};
+export declare type SettingsEvent = 'resizeRow' | 'hideColumn' | 'showColumn' | 'moveColumn';
+export declare type TableSettings = VariableSettings & {
+    enableSettings?: boolean;
+    settingsLabels?: SettingsLabels;
+    settingsTooltip?: TooltipProps;
+    onSettingsChange?: (event: SettingsEvent, settings: VariableSettings) => void;
+    hideableColumns?: string[];
+    sortableColumns?: string[];
+};

package/dist/components/newTable_v2/types/features/sort.d.ts

@@ -0,0 +1,15 @@
+import { SortDirection } from '@tanstack/react-table';
+export declare type OnSort<T> = (sortParams: {
+    sortBy: keyof T;
+    direction: false | SortDirection;
+}) => void;
+export declare type SortableTable<T> = {
+    sortable: true;
+    sortDescFirst?: boolean;
+    onSort?: OnSort<T>;
+} | {
+    sortable?: false;
+    sortDescFirst?: never;
+    onSort?: never;
+};
+export declare type CustomSorted = Record<string, false | SortDirection>;

package/dist/components/newTable_v2/types/index.d.ts

@@ -0,0 +1,10 @@
+export * from './cellsTypes';
+export * from './columnsTypes';
+export * from './enums';
+export * from './tableTypes';
+export * from './features/actions';
+export * from './features/highlight';
+export * from './features/pagination';
+export * from './features/selectRow';
+export * from './features/settings';
+export * from './features/sort';

package/dist/components/newTable_v2/types/tableTypes.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { ColumnsType } from './columnsTypes';
+import { RowSize } from './enums';
+import { TableActions } from './features/actions';
+import { HighlightRow } from './features/highlight';
+import { PaginatedTable } from './features/pagination';
+import { SelectableTable } from './features/selectRow';
+import { TableSettings } from './features/settings';
+import { SortableTable } from './features/sort';
+export declare type TableProps<T> = SelectableTable & PaginatedTable & SortableTable<T> & TableSettings & HighlightRow<T> & TableActions<T> & {
+    absoluteElementsPortal?: HTMLElement;
+    actionColumnWidth?: number;
+    bodyHeight?: number;
+    columns: ColumnsType<T>[];
+    data: T[];
+    headerSize?: RowSize;
+    isLoading?: boolean;
+    isRowDisabled?: (row: Row<T>) => boolean;
+    loadingStyle?: LoadingStyle;
+    onRowClick?: (row: Row<T>) => void;
+    renderEmptyState?: () => JSX.Element;
+    rowTooltip?: (row: Row<T>) => string;
+    showFooter?: boolean;
+    uniqueId: keyof T;
+};
+export declare type LoadingStyle = {
+    backgroundColor?: string;
+    foregroundColor?: string;
+    height?: number | string;
+    width?: number | string;
+};
+export declare type TableComponent = 'tableContainer' | 'table' | 'paginator' | 'tableBody' | 'tableRow' | 'bulkBar' | 'bulkBarContent' | 'bulkBarActions' | 'tableFooter' | 'tableFooterRow' | 'tableFooterCell' | 'tableHeader' | 'tableHeaderRow' | 'tableHeaderCell';

package/dist/components/newTable_v2/utils.d.ts

@@ -0,0 +1,18 @@
+import { SortDirection } from '@tanstack/react-table';
+import { DefaultTheme } from 'styled-components';
+import { ColumnsType } from './types';
+export declare const getNextSortingDirection: (direction?: false | SortDirection | undefined) => false | SortDirection;
+declare type MapBackgrounProps = {
+    isDisabled: boolean;
+    isRowHighlighted?: boolean;
+    rowHighlightColor?: string;
+    selected: boolean;
+    theme: DefaultTheme;
+};
+export declare type MappedProps = {
+    backgroundColor: string;
+    backgroundHover: string;
+};
+export declare const mapBackground: ({ isDisabled, isRowHighlighted, rowHighlightColor, selected, theme, }: MapBackgrounProps) => MappedProps;
+export declare const getColumnId: <T>(column: ColumnsType<T>) => string;
+export {};

package/dist/components/switch/Switch.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
 import { SwitchProps } from '.';
-declare const Switch: ({ checked, color, onChange, disabled }: SwitchProps) => JSX.Element;
+declare const Switch: ({ checked, color, disabled, onChange }: SwitchProps) => JSX.Element;
 export default Switch;

package/dist/components/tag/styled.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { TagParts } from './tagPalette';
 import { StyledTagProps } from './types';
-export declare const LeftIcon: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
-export declare const RightIcon: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const LeftIcon: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const RightIcon: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
 export declare const Text: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const StyledTag: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, TagParts & StyledTagProps, import("./tagPalette").tagParts>;

package/dist/components/toast/components/ToastContent.d.ts

@@ -5,7 +5,7 @@ export declare const StyledHeader: import("styled-components").StyledComponent<"
 export declare const ActionButton: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("../../buttons").ButtonProps & import("react").RefAttributes<HTMLDivElement | HTMLAnchorElement>>, import("styled-components").DefaultTheme, {}, never>;
 export declare const StyledIconContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const StyledTitle: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
-export declare const StyledIcon: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledIcon: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
 export declare const StyledTitleText: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
     type: ToastType;
 }, never>;

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

@@ -1,23 +1,5 @@
-import { BasePlacement } from '@popperjs/core';
-import { MouseEventHandler, ReactNode } from 'react';
-import { IconProps } from '../icon';
-import { MessageProps } from './components/Message';
+/// <reference types="react" />
+import { TooltipProps } from './types';
 export declare const defaultTooltipProps: TooltipProps;
-export interface TooltipProps extends MessageProps {
-    callbackAfterTimeout?: () => void;
-    children?: ReactNode;
-    className?: string;
-    hideAfterSeconds?: number;
-    icon?: IconProps;
-    message: string | JSX.Element;
-    onMouseEnter?: MouseEventHandler;
-    onMouseLeave?: MouseEventHandler;
-    onOpen?: (isOpen: boolean) => void;
-    placement: BasePlacement;
-    renderButton?: () => JSX.Element;
-    showAfterSeconds?: number;
-    showAlways?: boolean;
-    shouldRender?: boolean;
-}
-declare const Tooltip: ({ message, placement, className, children, type, onMouseEnter, onMouseLeave, showAlways, showAfterSeconds, hideAfterSeconds, callbackAfterTimeout, onOpen, icon, renderButton, shouldRender, }: TooltipProps) => JSX.Element;
+declare const Tooltip: ({ callbackAfterTimeout, children, className, hideAfterSeconds, icon, message, onMouseEnter, onMouseLeave, onOpen, placement, positionStrategy, renderButton, shouldRender, showAfterSeconds, showAlways, style, type, }: TooltipProps) => JSX.Element;
 export default Tooltip;

package/dist/components/tooltip/TooltipPopup.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { TooltipProps } from './types';
+import { UseTooltipValue } from './useTooltip';
+declare type TooltipPopupProps<W extends HTMLElement, C extends HTMLElement> = Pick<TooltipProps, 'icon' | 'message' | 'renderButton' | 'type'> & Pick<UseTooltipValue<W, C>, 'showTooltip' | 'popperRef' | 'styles' | 'setArrowRef' | 'attributes'> & {
+    shouldRender: boolean;
+};
+declare const TooltipPopup: <W extends HTMLElement, C extends HTMLElement>({ attributes, icon, message, popperRef, renderButton, setArrowRef, shouldRender, showTooltip, styles, type, }: TooltipPopupProps<W, C>) => JSX.Element;
+export default TooltipPopup;

package/dist/components/tooltip/components/Arrow.d.ts

@@ -0,0 +1,5 @@
+import { tooltipTypes } from '../tooltipPalette';
+export declare const Arrow: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    type: tooltipTypes;
+}, never>;
+export declare const arrowStyle: import("styled-components").FlattenSimpleInterpolation;

package/dist/components/tooltip/index.d.ts

@@ -1,3 +1,4 @@
-import Tooltip, { TooltipProps } from './Tooltip';
-import tooltipPalette, { TooltipPalette } from './tooltipPalette';
-export { Tooltip, TooltipProps, tooltipPalette, TooltipPalette };
+export { default as Tooltip } from './Tooltip';
+export { defaultTooltipProps } from './Tooltip';
+export * from './types';
+export * from './tooltipPalette';

package/dist/components/tooltip/styled.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
 export declare const BodyAnimationWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
-export declare const MessageIcon: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const MessageIcon: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
 export declare const ButtonContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/dist/components/tooltip/tooltipPalette.d.ts

@@ -3,5 +3,4 @@ export declare type tooltipTypes = 'dark' | 'light';
 export declare type TooltipPalette = {
     [key in tooltipTypes]: colorsPalette;
 };
-declare const tooltipPalette: TooltipPalette;
-export default tooltipPalette;
+export declare const tooltipPalette: TooltipPalette;

package/dist/components/tooltip/types.d.ts

@@ -0,0 +1,23 @@
+import { BasePlacement } from '@popperjs/core';
+import React, { MouseEventHandler, ReactNode } from 'react';
+import { IconProps } from '../icon';
+import { tooltipTypes } from './tooltipPalette';
+export interface TooltipProps {
+    callbackAfterTimeout?: () => void;
+    children?: ReactNode;
+    className?: string;
+    hideAfterSeconds?: number;
+    icon?: IconProps;
+    message: string | JSX.Element;
+    onMouseEnter?: MouseEventHandler;
+    onMouseLeave?: MouseEventHandler;
+    onOpen?: (isOpen: boolean) => void;
+    placement?: BasePlacement;
+    positionStrategy?: 'fixed' | 'absolute';
+    renderButton?: () => JSX.Element;
+    showAfterSeconds?: number;
+    showAlways?: boolean;
+    shouldRender?: boolean;
+    style?: React.CSSProperties;
+    type?: tooltipTypes;
+}

package/dist/components/tooltip/useTooltip.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties, Dispatch, MouseEventHandler, MutableRefObject, SetStateAction } from 'react';
+import { TooltipProps } from './types';
+declare type UseTooltipParams = Pick<TooltipProps, 'callbackAfterTimeout' | 'hideAfterSeconds' | 'onMouseEnter' | 'onMouseLeave' | 'onOpen' | 'placement' | 'showAfterSeconds' | 'showAlways' | 'positionStrategy'>;
+export declare type UseTooltipValue<W extends HTMLElement, C extends HTMLElement> = {
+    _onMouseEnter: MouseEventHandler;
+    _onMouseLeave: MouseEventHandler;
+    attributes: Record<string, Record<string, string> | undefined>;
+    childrenRef: MutableRefObject<C | null>;
+    popperRef: MutableRefObject<HTMLDivElement | null>;
+    setArrowRef: Dispatch<SetStateAction<HTMLDivElement | null>>;
+    show: () => void;
+    showTooltip: boolean | undefined;
+    styles: Record<string, CSSProperties>;
+    wrapperRef: MutableRefObject<W | null>;
+};
+declare const useTooltip: <W extends HTMLElement, C extends HTMLElement>({ callbackAfterTimeout, hideAfterSeconds, onMouseEnter, onMouseLeave, onOpen, placement, positionStrategy, showAfterSeconds, showAlways, }: UseTooltipParams) => UseTooltipValue<W, C>;
+export default useTooltip;