@economic/taco 1.1.7 → 1.1.8

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

@@ -0,0 +1,284 @@
+import React from 'react';
+import { Cell, ColumnInstance, IdType, Row as BaseRow, TableInstance, UseExpandedRowProps, UseRowSelectRowProps, UseRowStateRowProps, UseSortByColumnProps } from 'react-table';
+import { IconName } from '../Icon/components';
+export declare type SortDirection = 'asc' | 'desc';
+export declare type SortTypes = 'datetime' | 'string' | 'number' | 'boolean' | 'auto';
+export declare type RowIndexPath = string | undefined;
+export declare type Row<TRow extends {}> = TRow & {
+    subRows?: Row<TRow>[];
+};
+export declare type TableRow<TRow> = {
+    /**
+     * Index of the row.
+     * Note: This index is relative to the root or parent row if it is a sub row
+     * If you need full path of the row from the root, use indexPath
+     */
+    index: number;
+    /**
+     * Index path (dot notated) of the row.
+     * Note: This path is a dot notation of indexes to the root
+     */
+    indexPath: string;
+    depth?: number;
+    /**
+     * Define whether the row is expanded.
+     * If expended, `rowExpansionRenderer` render function will be called.
+     * It can be used to render a specific icon in your cell based on the state of the row.
+     */
+    isExpanded?: boolean;
+    /**
+     * Toggles the row expansion.
+     * It can be used as a handler for the click event on your cell.
+     */
+    toggleRowExpanded?: () => void;
+    /** Represents the values rendered in each cell */
+    values: Row<TRow>;
+    isEditing?: boolean;
+    toggleRowEditing?: () => void;
+};
+export declare type TableCell<TRow> = {
+    accessor: string;
+    /** Represents the row which renders the specific cell, exposing its properties */
+    row: TableRow<TRow>;
+    /** Access the rendered value in the cell */
+    value: any;
+};
+export declare type TableColumnProps<TRow> = {
+    /**
+     * This string is used to build the data model for your column.
+     * It should match one of the properties defined in your `data` object on `Table`,
+     * since this will map the value from the provided data.
+     * If the accessor doesn't match a property from table's `data`,
+     * you should render something using the `cellRenderer` prop.
+     */
+    accessor: string;
+    /**
+     * Align column's content.
+     * Not specifying this will default to a `centered` column
+     */
+    align?: 'left' | 'center' | 'right';
+    /** Add a classname to the column */
+    className?: string;
+    /**
+     * Define the content of the cell.
+     * It needs to be a render function that can return a transformed version of the existing value,
+     * or any valid react node, for e.g. a `div`
+     */
+    cellRenderer?: (cellProps: TableCell<TRow>) => React.ReactNode;
+    /** Disable sorting on column */
+    disableSorting?: boolean;
+    editRenderer?: (cellProps: TableCell<TRow>) => React.ReactNode;
+    /**
+     * Specify the width and growth characteristics of a column.
+     * This follows the standard flex-box `flex` css property
+     */
+    flex?: string | ((row: TRow) => string);
+    /** Text displayed in the column header */
+    headRenderer?: React.ReactNode;
+    /** Hides the column */
+    hidden?: boolean;
+    /** Hides the column on all sub rows */
+    hiddenOnSubRows?: boolean;
+    /**
+     * Specify the sort rule on a column.
+     * Specifying no value defaults to no sorting rule
+     */
+    sort?: SortDirection;
+    /**
+     * Sort type on a column is used to compare 2 rows of data and order them correctly based on the specified type.
+     * Default value is `auto`, which will apply sort type based on the type of your column's value.
+     * `auto` will use type checking for booleans or numbers before falling back to string
+     */
+    sortType?: SortTypes;
+    /**
+     * Use inline style for your column.
+     * *Note* that `flex` should be set using `flex` prop, otherwise it will be overriden here by `undefined`
+     */
+    style?: object;
+};
+export declare type TableGroupProps<TRow> = {
+    /** Content of a group should be another `Table.Group` or a `Table.Column` */
+    children: React.ReactElement<TableColumnProps<TRow>> | React.ReactElement<TableColumnProps<TRow>>[];
+    /** Hide the entire group (and columns defined within group) */
+    hidden?: boolean;
+    /** Text displayed in the group's header */
+    title: string;
+};
+export declare type RowClickHandler<TRow> = (row: TableRow<TRow>, event: React.MouseEvent) => void;
+export declare type RowDragHandler<TRow> = (rows: Array<TableRow<TRow>>, showPlaceholder: (placeholder: string) => void, event: React.DragEvent) => void;
+export declare type SortRule<T> = {
+    /** Name of the accessor you want to sort */
+    accessor: IdType<T>;
+    /** Set whether it is a descending sort direction */
+    desc?: boolean;
+};
+export declare type SelectedRowsState = Record<number, boolean>;
+export declare type SelectedRowsHandler = React.Dispatch<React.SetStateAction<SelectedRowsState>>;
+export declare type SortHandler<T> = (sortRules: SortRule<T>[] | undefined, sortedData?: T[]) => void;
+export declare type PaginationHandler = (pageNumber: number, pageSize: number) => void;
+export declare type RowCreateHandler<TRow> = (parentRow: TableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowEditHandler<TRow> = (row: TableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowCopyHandler<TRow> = (row: TableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowDeleteHandler<TRow> = (row: TableRow<TRow>, event: React.MouseEvent<HTMLButtonElement>) => void;
+export declare type RowActiveHandler<TRow> = (row: TableRow<TRow>) => void;
+export declare type RowAction<TRow> = {
+    disabled?: ((row: TableRow<TRow>) => boolean) | boolean;
+    icon: ((row: TableRow<TRow>) => IconName) | IconName;
+    onClick: (row: TableRow<TRow>, event: React.MouseEvent<HTMLElement>) => void;
+    text: ((row: TableRow<TRow>) => React.ReactNode) | React.ReactNode;
+    tooltip?: ((row: TableRow<TRow>) => string) | string;
+    showOnRow?: boolean;
+    visible?: ((row: TableRow<TRow>) => boolean) | boolean;
+};
+export declare type RowActionHandler<TRow> = RowAction<TRow> | undefined | null | boolean;
+export declare type TableProps<TRow> = React.HTMLAttributes<HTMLDivElement> & {
+    /** Autofocus the table when loaded */
+    autoFocus?: boolean;
+    /**
+     * Children should be one of the Table's components.
+     * Read about `ForwardedGenericTableWithStatics` for more details.
+     * *Note* that there can also be children that are rendered conditionally
+     */
+    children: TableChildren<TRow>;
+    /** Provide data to be displayed in your table */
+    data: Row<TRow>[];
+    /**
+     * This will attach the `keyDown` handler for Table to the window,
+     * so that user can directly navigate through table using keyboard, even if the table is not focused.
+     * *Note* that the `keydown` handler will be executed only if focus is on body or the table itself
+     */
+    dangerouslyHijackGlobalKeyboardNavigation?: boolean;
+    /**
+     * Provide an empty state to the table if there is no data or it is loading asynchronously
+     */
+    emptyStateRenderer?: () => React.ReactNode;
+    /** Handler called when a row is clicked */
+    onRowClick?: RowClickHandler<TRow>;
+    /** Handler called when a row is dragged */
+    onRowDrag?: RowDragHandler<TRow>;
+    /**
+     * Handler used toghether with `selectedRows`.
+     * *Note* that row selection should be used within a state since it is controlled.
+     * To enable row selection, you have to use both `selectedRows` and `onSelectedRows` - you can use standard `useState` for this
+     */
+    onSelectedRows?: SelectedRowsHandler;
+    /**
+     * Provide a className for rows.
+     * It can be a `string` or a render function that is given the properties of the row and returns a `string`
+     */
+    rowClassName?: string | ((row: TableRow<TRow>) => string | undefined);
+    /** Show extra content below each row */
+    rowExpansionRenderer?: (row: TableRow<TRow>) => React.ReactNode;
+    /** Give the row a specific height */
+    rowHeight?: number;
+    /**
+     * Used toghether with `onSelectedRows`.
+     * *Note* that row selection should be used within a state since it is controlled.
+     * To enable row selection, you have to use both `selectedRows` and `onSelectedRows` - you can use standard `useState` for this
+     */
+    selectedRows?: SelectedRowsState;
+    activeIndex?: number;
+    defaultActiveIndex?: number;
+    onChangeActiveIndex?: (activeIndex: number) => void;
+    /** Disable sorting on the entire table */
+    disableSorting?: boolean;
+    /**
+     * Handler which passes back the current sorting state and sorted data.
+     * You can use this if you need to handle in some way the current sort values,
+     * for e.g. to save them in localstorage and pass them back as `sortRules`
+     */
+    onSort?: SortHandler<TRow>;
+    /** Enable manual (external) sorting */
+    manualSorting?: boolean;
+    /**
+     * Provide the initial sorting rules on your table.
+     * *Note* that these values will override any default sorting specified on columns
+     */
+    sortRules?: SortRule<TRow>[];
+    disablePagination?: boolean;
+    length?: number;
+    /** Handler called when navigating through pages */
+    onPaginate?: PaginationHandler;
+    /** Current page index (zero based) */
+    pageIndex?: number;
+    /** Number of items displayed on a page */
+    pageSize?: number;
+    /** Handler called as user scrolls a virtualised window */
+    loadMore?: (startIndex: number, endIndex: number) => void;
+    /** Enable inline editing mode by providing the property name of a unique id in your data */
+    inlineEditingUniqueId?: keyof TRow;
+    /** Handler called when a new row is added - without this property defined the 'add new row' button will not be visible */
+    onRowCreate?: RowCreateHandler<TRow>;
+    /** Collection of items/links to show in the actions menu - without this property defined the actions men button will not be visible */
+    actions?: RowActionHandler<TRow>[];
+    /** Handler called when a row is edited - without this property defined the 'edit row' button will not be visible - unless inline editing mode is set */
+    onRowEdit?: RowEditHandler<TRow>;
+    /** Handler called when a row is copied - without this property defined the 'copy row' button will not be visible */
+    onRowCopy?: RowCopyHandler<TRow>;
+    /** Handler called when a row is deleted - without this property defined the 'delete row' button will not be visible */
+    onRowDelete?: RowDeleteHandler<TRow>;
+    /** Handler called when a row is made active */
+    onRowActive?: RowActiveHandler<TRow>;
+};
+export declare type TableRef = HTMLDivElement & {
+    instance: {
+        toggleAllRowsExpanded: any;
+        toggleHideAllColumns: any;
+        toggleHideColumn: any;
+        toggleEditing: any;
+        toggleRowEditing: any;
+        resetRowEditing: any;
+        toggleRowExpanded: any;
+        toggleSortBy: any;
+    };
+};
+export declare type ForwardedGenericTableWithStatics = React.ForwardRefExoticComponent<TableProps<any> & React.RefAttributes<HTMLDivElement>> & {
+    /** Represents a column in your table */
+    Column: <TRow>(props: TableColumnProps<TRow>) => JSX.Element | null;
+    /**
+     * Container for columns.
+     * Visually this adds a column above and spans all group children.
+     * *Note* that groups can only be nested two levels deep
+     */
+    Group: <TRow>(props: TableGroupProps<TRow>) => JSX.Element | null;
+} & (<TRow>(props: TableProps<TRow> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => JSX.Element);
+export declare type TableChild<TRow> = React.ReactElement<TableColumnProps<TRow>> | React.ReactElement<TableGroupProps<TRow>> | boolean | null;
+export declare type TableChildren<TRow> = TableChild<TRow> | TableChild<TRow>[];
+/** @internal */
+export declare type InternalTableColumn = TableColumnProps<any> & ColumnInstance & UseSortByColumnProps<{}> & {
+    className?: string;
+};
+/** @internal */
+export declare type InternalTableCell = TableCell<any> & Cell & {
+    column: InternalTableColumn;
+};
+/** @internal */
+export declare type InternalTableRow = TableRow<any> & BaseRow & UseExpandedRowProps<{}> & UseRowSelectRowProps<{}> & UseRowStateRowProps<{}>;
+/** @internal */
+export declare type InternalBaseTable = Partial<TableProps<any>> & Partial<TableInstance> & {
+    children: JSX.Element;
+    headerRef?: React.MutableRefObject<HTMLDivElement | null>;
+    bodyRef?: React.MutableRefObject<HTMLDivElement | null>;
+};
+/** @internal */
+export declare type InternalTable = {
+    rowProps: Pick<TableProps<any>, 'inlineEditingUniqueId' | 'onRowClick' | 'rowClassName' | 'rowExpansionRenderer'> & {
+        activeIndex?: number;
+        setActiveIndex?: any;
+        rowHeight: number | undefined;
+    };
+    tableProps: any;
+    state: any;
+    pagination: {
+        length: number;
+        pageSize: number;
+        pageIndex: number;
+        setPageIndex: (index: number) => void;
+        setPageSize: (size: number) => void;
+    } | null;
+    rows: any[];
+    prepareRow: (row: any, index: number) => void;
+    instance: any;
+};

package/dist/components/Table/util/renderColumn.d.ts

@@ -0,0 +1 @@
+export declare const Column: ({ cell }: any) => any;

package/dist/components/Table/util/renderRow.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const Row: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;

package/dist/components/Table/util/rowIndexPath.d.ts

@@ -0,0 +1,5 @@
+import { Row, RowIndexPath } from '../types';
+export declare const convertRowIndexPathToNumberArray: (rowIndexPath: RowIndexPath) => number[];
+export declare const getByRowIndexPath: <TRow>(data: Row<TRow>[], rowIndexPath: RowIndexPath) => Row<TRow> | undefined;
+export declare const setByRowIndexPath: <TRow>(data: Row<TRow>[], rowIndexPath: RowIndexPath, values: any) => Row<TRow>[];
+export declare const getParentRowIndexPath: (rowIndexPath: RowIndexPath) => RowIndexPath;

package/dist/components/Table/util/sortTypes.d.ts

@@ -0,0 +1,4 @@
+import { SortTypes, TableRow } from '../types';
+declare type SortHandler<T> = (rowA: TableRow<T>, rowB: TableRow<T>, columnId: string) => 0 | 1 | -1;
+export declare const sortTypes: Record<SortTypes, SortHandler<any>>;
+export {};

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

@@ -0,0 +1,12 @@
+import { TableRow, TableChildren, InternalTableRow, SortRule } from './types';
+import { SortingRule } from 'react-table';
+export declare const sanitizeRowProps: (row: InternalTableRow, rowExpansionRenderer: any) => TableRow<any>;
+export declare const getColumnsFromChildren: (children: TableChildren<any>, rowExpansionRenderer: any) => {
+    columns: (import("./types").TableColumnProps<any> & import("react-table").ColumnInstance<{}> & import("react-table").UseSortByColumnProps<{}> & {
+        className?: string | undefined;
+    } & {
+        disableSortBy: boolean | undefined;
+    })[];
+    sortRules: SortingRule<any>[];
+};
+export declare const getInternalSortRules: <T>(sortRules: SortRule<T>[] | undefined) => SortingRule<T>[] | undefined;

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

@@ -0,0 +1,55 @@
+import * as React from 'react';
+import { Orientation } from '../../types';
+import './Tabs.css';
+export declare type TabsProps = React.HTMLAttributes<HTMLDivElement> & {
+    /**
+     * The controlled value of the tab to activate. Should be used in conjunction with `onChange`.
+     */
+    id?: string;
+    /**
+     * Set which tab is selected on mount.
+     * This has to be one of the existing ids provided for tabs
+     */
+    defaultId?: string;
+    /**
+     * Content should be one or an array of `Tabs.Trigger` components inside `Tabs.List` and then
+     * followed by one or an array of `Tabs.Content`.
+     * *Note* that there can also be tabs that are rendered conditionally.
+     */
+    children: React.ReactNode;
+    /**
+     * Define orientation of tabs.
+     * @defaultValue horizontal
+     */
+    orientation?: Orientation;
+    /**
+     * Callback that is called when tab is changed.
+     */
+    onChange?: (id: string) => void;
+};
+export declare type TabListProps = React.HTMLAttributes<HTMLDivElement>;
+export declare type TabTriggerProps = React.HTMLAttributes<HTMLButtonElement> & {
+    /**
+     * A unique value that associates the trigger with a content.
+     */
+    id: string;
+    /**
+     * When true, prevents the user from interacting with the tab.
+     */
+    disabled?: boolean;
+};
+export declare type TabContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    /**
+     * A unique value that associates the content with a trigger.
+     */
+    id: string;
+};
+export declare type ForwardedTabsWithStatics = React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>> & {
+    /** Tab list component containing all tab triggers, rendered in a `Tabs` group component */
+    List: React.ForwardRefExoticComponent<TabListProps & React.RefAttributes<HTMLDivElement>>;
+    /** Tab trigger component rendered in a `Tabs.List` component */
+    Trigger: React.ForwardRefExoticComponent<TabTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    /** Tab content component rendered in a `Tabs` group component */
+    Content: React.ForwardRefExoticComponent<TabContentProps & React.RefAttributes<HTMLDivElement>>;
+};
+export declare const Tabs: ForwardedTabsWithStatics;

package/dist/components/Textarea/Textarea.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+export declare type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    /** Draws attention to the textarea by changing its style and making it visually prominent */
+    highlighted?: boolean;
+    invalid?: boolean;
+    /** Value of the textarea */
+    value?: string;
+};
+export declare const Textarea: React.ForwardRefExoticComponent<React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    /** Draws attention to the textarea by changing its style and making it visually prominent */
+    highlighted?: boolean | undefined;
+    invalid?: boolean | undefined;
+    /** Value of the textarea */
+    value?: string | undefined;
+} & React.RefAttributes<HTMLTextAreaElement>>;

package/dist/components/Toast/Toast.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import { State } from '../../types';
+export declare type ToastsTexts = {
+    /** Aria-label for the close icon button of toast */
+    dismiss: string;
+};
+export declare type ToastType = Omit<State, 'default'> | 'loading';
+export declare type ToastOptions = {
+    /** Provide time in milliseconds after which the toast should autoclose */
+    autoClose?: number;
+    /**
+     * State will change the icon displayed in toast and other characteristics,
+     * for e.g. `loading` state will display a progress animation.
+     * Default value is `default`
+     */
+    type?: ToastType;
+};
+export declare type ToastProps = {
+    /** Provide a unique id for toast */
+    id: string;
+    /**
+     * Content can be any valid react node, for e.g. a `div`, or a simple text.
+     * Note that content can also be `null`, resulting in a slimmer version of your toast with a vertically centered title
+     */
+    content: React.ReactNode;
+    /** Additional options to define your toast */
+    options: ToastOptions;
+    /**
+     * Handler called when toast closes.
+     * To read more about how to provide the text, see [Provider](component:provider) component
+     */
+    onClose: () => void;
+    lastUpdated?: number;
+    lastDuplicateId?: string;
+};
+export declare const Toast: ({ content, lastUpdated, onClose: handleClose, options, ...props }: ToastProps) => JSX.Element;

package/dist/components/Toast/Toaster.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { ToastOptions } from './Toast';
+import './Toast.css';
+declare type ToastCreator<T> = (content: React.ReactNode | ((close: () => void) => React.ReactNode), options?: ToastOptions) => T;
+export interface Toaster<T> extends ToastCreator<T> {
+    success: ToastCreator<T>;
+    error: ToastCreator<T>;
+    warning: ToastCreator<T>;
+    information: ToastCreator<T>;
+    loading: ToastCreator<T>;
+}
+export interface ToastReference {
+    /** Show a success toast */
+    success: ToastCreator<void>;
+    /** Show an error toast */
+    error: ToastCreator<void>;
+    /** Show a warning toast */
+    warning: ToastCreator<void>;
+    /** Show an information toast */
+    information: ToastCreator<void>;
+    /** Show a loading toast */
+    loading: ToastCreator<void>;
+    /**
+     * Close an existing toast.
+     * The toast function returns a reference to the active toast,
+     * allowing you to programmatically close it when needed
+     */
+    close: () => void;
+}
+export interface ToastProviderProps {
+    children: React.ReactNode;
+}
+export declare const ToastProvider: ({ children, ...props }: ToastProviderProps) => JSX.Element;
+export declare const useToast: () => Toaster<ToastReference>;
+export {};

package/dist/components/Toast/util.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { ToastType } from './Toast';
+export declare const getBadgeIcon: (type: ToastType) => JSX.Element | null;

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

@@ -0,0 +1,23 @@
+import * as React from 'react';
+export declare type TooltipProps = React.HTMLAttributes<HTMLDivElement> & {
+    /** The element which activates the tooltip when hovered. Should be a single React/HTML element */
+    children: React.ReactElement | any;
+    /** Text displayed in the tooltip */
+    title: string;
+    /**
+     *  Placement of the tooltip relative to the reference element. Placement will be reversed if a collision occurs
+     * @defaultValue bottom
+     */
+    placement?: 'top' | 'right' | 'bottom' | 'left';
+};
+export declare const Tooltip: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    /** The element which activates the tooltip when hovered. Should be a single React/HTML element */
+    children: React.ReactElement | any;
+    /** Text displayed in the tooltip */
+    title: string;
+    /**
+     *  Placement of the tooltip relative to the reference element. Placement will be reversed if a collision occurs
+     * @defaultValue bottom
+     */
+    placement?: "top" | "right" | "bottom" | "left" | undefined;
+} & React.RefAttributes<HTMLElement>>;

package/dist/components/Tour/Tour.d.ts

@@ -0,0 +1,70 @@
+import * as React from 'react';
+import { Placement } from 'react-joyride';
+export declare type TourTexts = {
+    /** Text for back action button */
+    back: string;
+    /**
+     * Text for close button.
+     * This button is displayed if tour is not continuous - replacing the `Next` button.
+     * It will pause the flow of the tour and close the tooltip
+     */
+    close: string;
+    /**
+     * Aria-label and title for close icon button in each step.
+     * This button skips and completes the flow entirely
+     */
+    skip: string;
+    /**
+     * Text for last action button.
+     * This button is displayed when user is on the last step of the tour
+     */
+    last: string;
+    /**
+     * Text for next action button.
+     * This button is displayed if tour has more than one steps and is continuous
+     */
+    next: string;
+    /** Aria label and title for beacon that will open the tour step */
+    open: string;
+};
+export declare type TourStepProps = {
+    /** Content can be any valid react node, for e.g. a `div` */
+    children: React.ReactNode;
+    /** Define the position of the tour's popup relative to the element is presenting */
+    position?: Placement;
+    /** The css selector of the html element you want to include in a tour */
+    selector: string;
+    /**
+     * Show beacon for step.
+     * A beacon is a styled component which indicates the current element to be presented.
+     * For more informations about how to create a beacon, read [Joyride](https://docs.react-joyride.com) docs
+     */
+    showBeacon?: boolean;
+    /** Text displayed above the children/content of the popup  */
+    title: string;
+};
+export declare const TourStep: (_props: TourStepProps) => null;
+export declare type TourProps = {
+    /** Controls if [Joyride](https://docs.react-joyride.com) is active */
+    autoStart?: boolean;
+    /** Children should be one or more `Tour.Step` components */
+    children: any;
+    /** Are there more than one steps and should you be able to navigate between them using `Next` and `Previous` buttons */
+    continuous?: boolean;
+    /** Disable closing of tour when click on `Escape` */
+    disableCloseOnEsc?: boolean;
+    /** Don't close the presenting popup of the tour step when clicking outside it */
+    disableOverlayClose?: boolean;
+    /** Allows user to interact with the presented components (mouse and touch events) when the popup is visible */
+    disableScrolling?: boolean;
+    onClose?: (step: TourStepProps) => void;
+    onComplete?: Function;
+    /** When step is ready */
+    onReady?: (step: TourStepProps) => void;
+    spotlightClicks?: boolean;
+    disableScrollParentFix?: boolean;
+};
+export declare const Tour: {
+    (props: TourProps): JSX.Element;
+    Step: (_props: TourStepProps) => null;
+};

package/dist/components/Treeview/Treeview.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export declare type TreeviewItemProps = React.LinkHTMLAttributes<HTMLAnchorElement>;
+export declare type TreeviewGroupProps = Omit<React.LinkHTMLAttributes<HTMLDivElement>, 'className' | 'onClick' | 'title'> & {
+    /** Add a classname to the treeview */
+    className?: string | ((expanded: boolean) => string);
+    /**
+     * Set wheter the region is expanded, showing the children, or collapsed.
+     * Default value is `false`
+     */
+    expanded?: boolean;
+    /** Region is expanded at mount and can't be collapsed */
+    fixed?: boolean;
+    /** Handler called when user clicks the title of the group */
+    onClick?: (event: React.MouseEvent<HTMLDivElement>, expanded: boolean) => void;
+    /** Text displayed in the group's header */
+    title: React.ReactNode | ((expanded: boolean) => React.ReactNode);
+};
+export declare type TreeviewProps = React.HTMLAttributes<HTMLDivElement>;
+export declare type ForwardedTreeviewWithStatics = React.ForwardRefExoticComponent<TreeviewProps & React.RefAttributes<HTMLDivElement>> & {
+    /** Navigable link */
+    Item: React.ForwardRefExoticComponent<TreeviewItemProps & React.RefAttributes<HTMLAnchorElement>>;
+    /** Container for a set of related links, usually expandable */
+    Group: React.ForwardRefExoticComponent<TreeviewGroupProps & React.RefAttributes<HTMLDivElement>>;
+};
+export declare const Treeview: ForwardedTreeviewWithStatics;

package/dist/components/VisuallyHidden/VisuallyHidden.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+declare type Props = React.HTMLAttributes<HTMLSpanElement>;
+export declare const VisuallyHidden: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLSpanElement>>;
+export {};

package/dist/esm/_virtual/_rollupPluginBabelHelpers.js

@@ -0,0 +1,34 @@
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+export { _extends as extends, _objectWithoutPropertiesLoose as objectWithoutPropertiesLoose };
+//# sourceMappingURL=_rollupPluginBabelHelpers.js.map

package/dist/esm/_virtual/_rollupPluginBabelHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_rollupPluginBabelHelpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}