@neo4j-ndl/react 2.0.0-alpha-e609471 → 2.0.0-alpha-5e223d7

package/lib/types/accordion/Accordion.d.ts

@@ -18,7 +18,7 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-/// <reference types="react" />
+import React from 'react';
 import { type ElementBase } from '../helpers';
 export type AccordionItemId = string | number;
 export interface AccordionBase extends ElementBase<HTMLDivElement> {
@@ -39,7 +39,6 @@ interface IsMultiple<T extends AccordionItemId> {
 type AccordionIsMultiple<T extends AccordionItemId> = AccordionBase & IsMultiple<T>;
 type AccordionIsNotMultiple<T extends AccordionItemId> = AccordionBase & IsNotMultiple<T>;
 export type AccordionProps<T extends AccordionItemId> = AccordionIsMultiple<T> | AccordionIsNotMultiple<T>;
-declare const Accordion: <T extends AccordionItemId>(props: AccordionProps<T> & import("react").RefAttributes<unknown>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null;
 export type AccordionArrowPosition = 'left' | 'right';
 export interface AccordionItemProps<T extends AccordionItemId> extends ElementBase<HTMLDivElement> {
     /** The component item id. */
@@ -53,8 +52,10 @@ export interface AccordionItemProps<T extends AccordionItemId> extends ElementBa
     /** If the component item is disabled. */
     disabled?: boolean;
 }
-declare const AccordionNamespace: (<T extends AccordionItemId>(props: AccordionProps<T> & import("react").RefAttributes<unknown>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null) & {
-    Item: <T_1 extends AccordionItemId>({ itemId, children, title, className, arrowPosition, disabled, onExpandedChange, ...restProps }: AccordionItemProps<T_1>) => import("react/jsx-runtime").JSX.Element;
+declare const Accordion: (<T extends AccordionItemId>(props: AccordionProps<T> & React.RefAttributes<unknown>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null) & {
+    Item: {
+        <T_1 extends AccordionItemId>({ itemId, children, title, className, arrowPosition, disabled, onExpandedChange, ...restProps }: AccordionItemProps<T_1>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
 };
-export { AccordionNamespace as Accordion };
-export default Accordion;
+export { Accordion };

package/lib/types/banner/Banner.d.ts

@@ -27,7 +27,7 @@ import { type ElementBase } from '../helpers';
  *
  *
  */
-export interface BannerActionProps extends React.HTMLProps<HTMLAnchorElement> {
+export interface BannerActionsProps extends React.HTMLProps<HTMLAnchorElement> {
     /** Label of the action item */
     label: string;
     /** Event handler when the action button is clicked. If set, the element is rendered as `button` */
@@ -54,7 +54,7 @@ export interface BannerCommonProps extends Omit<ElementBase, 'title'> {
     /** Shows status icon. Icon is automatically picked based on `type` value   */
     icon?: boolean;
     /** Shows Action buttons in the footer */
-    actions?: BannerActionProps[];
+    actions?: BannerActionsProps[];
     /** Adds shadow */
     floating?: boolean;
 }
@@ -71,6 +71,10 @@ type NonCloseableBannerProps = {
 type BannerCloseProps = CloseableBannerProps | NonCloseableBannerProps;
 export type BannerProps = BannerCommonProps & BannerCloseProps;
 export type BannerType = 'info' | 'success' | 'warning' | 'danger';
-export declare const BannerAction: ({ label, ...props }: BannerActionProps) => import("react/jsx-runtime").JSX.Element;
-export declare const Banner: React.ForwardRefExoticComponent<BannerProps & React.RefAttributes<HTMLDivElement>>;
-export default Banner;
+declare const Banner: React.ForwardRefExoticComponent<BannerProps & React.RefAttributes<HTMLDivElement>> & {
+    Actions: {
+        ({ label, ...props }: BannerActionsProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export { Banner };

package/lib/types/context-menu/ContextMenu.d.ts

@@ -39,13 +39,11 @@ export interface ContextMenuProps extends PopoverProps {
     /** Whether the menu is nested. Internal prop provided when nesting menu elements */
     nested?: boolean;
 }
-declare const Menu: React.ForwardRefExoticComponent<Omit<ContextMenuProps, "ref"> & React.RefAttributes<unknown>>;
 interface MenuItemsProps extends ElementBase {
     children: React.ReactNode | string;
     /** Additional classes */
     className?: string;
 }
-export declare const MenuItems: React.ForwardRefExoticComponent<Omit<MenuItemsProps, "ref"> & React.RefAttributes<unknown>>;
 interface StandardMenuItemProps extends Omit<ElementBase, 'title' | 'onClick' | 'children'> {
     /** Item title text */
     title: string | React.ReactNode;
@@ -65,7 +63,6 @@ interface StandardMenuItemProps extends Omit<ElementBase, 'title' | 'onClick' |
     /** Enforces no children on standard menu item. Overridden by nested menu item*/
     children?: never;
 }
-export declare const MenuItem: React.ForwardRefExoticComponent<(Omit<StandardMenuItemProps, "ref"> | Omit<NestedMenuItemProps, "ref">) & React.RefAttributes<unknown>>;
 declare const StandardMenuItem: React.ForwardRefExoticComponent<Omit<StandardMenuItemProps, "ref"> & React.RefAttributes<unknown>>;
 interface MenuHeaderProps extends Omit<ElementBase, 'title'> {
     /** Header title text */
@@ -75,17 +72,24 @@ interface MenuHeaderProps extends Omit<ElementBase, 'title'> {
     /** Additional classes */
     className?: string;
 }
-export declare const MenuHeader: React.ForwardRefExoticComponent<Omit<MenuHeaderProps, "ref"> & React.RefAttributes<unknown>>;
-declare const MenuNamespace: React.ForwardRefExoticComponent<Omit<ContextMenuProps, "ref"> & React.RefAttributes<unknown>> & {
-    Divider: () => import("react/jsx-runtime").JSX.Element;
-    Subheader: (props: {
-        title: string;
-    }) => import("react/jsx-runtime").JSX.Element;
-};
-export { MenuNamespace as Menu };
 type NestedMenuItemProps = Omit<React.ComponentProps<typeof StandardMenuItem>, 'children'> & {
     children: ({ nestedMenuProps, }: {
         nestedMenuProps: Pick<React.ComponentProps<typeof Menu>, 'className' | 'open' | 'anchorEl' | 'onClose' | 'onMouseLeave' | 'onKeyDown' | 'nested'>;
     }) => JSX.Element;
 };
-export declare const NestedMenuItem: React.ForwardRefExoticComponent<Omit<NestedMenuItemProps, "ref"> & React.RefAttributes<unknown>>;
+declare const Menu: React.ForwardRefExoticComponent<Omit<ContextMenuProps, "ref"> & React.RefAttributes<unknown>> & {
+    Divider: {
+        (): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Subheader: {
+        (props: {
+            title: string;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Header: React.ForwardRefExoticComponent<Omit<MenuHeaderProps, "ref"> & React.RefAttributes<unknown>>;
+    Item: React.ForwardRefExoticComponent<(Omit<StandardMenuItemProps, "ref"> | Omit<NestedMenuItemProps, "ref">) & React.RefAttributes<unknown>>;
+    Items: React.ForwardRefExoticComponent<Omit<MenuItemsProps, "ref"> & React.RefAttributes<unknown>>;
+};
+export { Menu };

package/lib/types/data-grid/Components.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="react" />
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+import { type RowData, type Row, type Cell, type Header as HeaderType, type CellContext, type SortDirection } from '@tanstack/react-table';
+import { type ElementBase } from '../helpers';
+import { Menu } from '../context-menu';
+import { type ColumnAction } from './datagrid-types';
+type MenuItemProps = React.ComponentProps<typeof Menu.Item>;
+export declare const DEFAULT_SORT_ACTIONS: (cell: HeaderType<any, unknown>) => {
+    [key in SortDirection | 'default']: ColumnAction;
+};
+export interface CommonInnerProps<T = HTMLDivElement> {
+    /** Children are surfaced to allow easy overriding */
+    children?: React.ReactNode;
+    innerProps?: ElementBase<T>;
+}
+export interface ResizingBarProps<T extends RowData> extends CommonInnerProps<HTMLButtonElement> {
+    header: HeaderType<T, unknown>;
+}
+declare const ResizingBar: <T extends unknown>({ header, children, innerProps, }: ResizingBarProps<T>) => import("react/jsx-runtime").JSX.Element;
+declare const Scrollable: ({ children, innerProps }: CommonInnerProps) => import("react/jsx-runtime").JSX.Element;
+declare const Header: ({ children, innerProps }: CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+export interface ActionButtonProps {
+    action: ColumnAction;
+    children?: React.ReactNode;
+    innerProps?: MenuItemProps;
+    /** Callback provided to close the context menu */
+    onClose: () => void;
+}
+export declare const ActionButton: ({ action, children, onClose, innerProps, }: ActionButtonProps) => import("react/jsx-runtime").JSX.Element;
+export interface RowActionCellProps<T extends RowData> {
+    cell?: CellContext<T, unknown>;
+    innerProps?: React.ComponentProps<typeof Menu>;
+}
+export declare const RowActionCell: <T extends unknown>({ cell, innerProps, }: RowActionCellProps<T>) => import("react/jsx-runtime").JSX.Element | null;
+export interface ColumnControlsProps<T extends RowData> extends CommonInnerProps<HTMLDivElement> {
+    cell: HeaderType<T, unknown>;
+}
+export declare const ColumnControls: <T extends unknown>({ cell, children, innerProps, }: ColumnControlsProps<T>) => import("react/jsx-runtime").JSX.Element | null;
+export interface HeaderCellProps<T> extends CommonInnerProps<HTMLDivElement> {
+    cell: HeaderType<T, unknown>;
+}
+declare const HeaderCell: <T extends unknown>({ cell, children, innerProps, }: HeaderCellProps<T>) => import("react/jsx-runtime").JSX.Element;
+declare const Body: ({ children, innerProps }: CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+export interface BodyCellProps<T extends RowData> extends CommonInnerProps<HTMLDivElement> {
+    cell: Cell<T, unknown>;
+}
+declare const BodyCell: <T extends unknown>({ cell, children, innerProps, }: BodyCellProps<T>) => import("react/jsx-runtime").JSX.Element;
+export interface BodyRowProps<T extends RowData> extends CommonInnerProps<HTMLDivElement> {
+    row: Row<T>;
+}
+declare const BodyRow: <T extends unknown>({ row, children, innerProps, }: BodyRowProps<T>) => import("react/jsx-runtime").JSX.Element;
+export interface TableResultProps extends CommonInnerProps<HTMLSpanElement> {
+    manualPagination?: {
+        from: number;
+        to: number;
+        totalRows: number;
+    };
+}
+declare const TableResults: ({ children, innerProps, manualPagination, }: TableResultProps) => import("react/jsx-runtime").JSX.Element;
+declare const RowsPerPage: ({ children, innerProps, }: CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+export interface PaginationArrowButtonProps extends CommonInnerProps<HTMLButtonElement> {
+    action: 'previous' | 'next';
+}
+declare const PaginationArrowButton: ({ action, children, innerProps, }: PaginationArrowButtonProps) => import("react/jsx-runtime").JSX.Element;
+export interface PaginationNumericButtonProps extends CommonInnerProps<HTMLButtonElement> {
+    currentIndex: number | string;
+    isSelected: boolean;
+}
+declare const PaginationNumericButton: ({ currentIndex, isSelected, children, innerProps, }: PaginationNumericButtonProps) => import("react/jsx-runtime").JSX.Element;
+declare const PaginationNumericButtons: () => import("react/jsx-runtime").JSX.Element;
+declare const Pagination: ({ children, innerProps, }: CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+declare const Navigation: ({ children, innerProps, }: CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+declare const LoadingPlaceholder: ({ children, innerProps, }: CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+declare const NoDataPlaceholder: ({ children, innerProps, }: CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+export { ResizingBar, Header, Body, BodyCell, BodyRow, HeaderCell, Navigation, TableResults, RowsPerPage, Pagination, PaginationNumericButtons, PaginationArrowButton, PaginationNumericButton, NoDataPlaceholder, LoadingPlaceholder, Scrollable, };

package/lib/types/data-grid/DataGrid.d.ts

@@ -0,0 +1,90 @@
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/// <reference types="react" />
+import { type ElementBase } from '../helpers';
+import type { RowData, Table as DataGridType } from '@tanstack/react-table';
+import { type DataGridComponentsInterface } from './DataGridContext';
+export declare const DataGridComponents: {
+    ResizingBar: <T extends unknown>({ header, children, innerProps, }: import("./Components").ResizingBarProps<T>) => import("react/jsx-runtime").JSX.Element;
+    Header: ({ children, innerProps }: import("./Components").CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+    Body: ({ children, innerProps }: import("./Components").CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+    BodyCell: <T_1 extends unknown>({ cell, children, innerProps, }: import("./Components").BodyCellProps<T_1>) => import("react/jsx-runtime").JSX.Element;
+    BodyRow: <T_2 extends unknown>({ row, children, innerProps, }: import("./Components").BodyRowProps<T_2>) => import("react/jsx-runtime").JSX.Element;
+    HeaderCell: <T_3 extends unknown>({ cell, children, innerProps, }: import("./Components").HeaderCellProps<T_3>) => import("react/jsx-runtime").JSX.Element;
+    ActionButton: ({ action, children, onClose, innerProps, }: import("./Components").ActionButtonProps) => import("react/jsx-runtime").JSX.Element;
+    ColumnControls: <T_4 extends unknown>({ cell, children, innerProps, }: import("./Components").ColumnControlsProps<T_4>) => import("react/jsx-runtime").JSX.Element | null;
+    Navigation: ({ children, innerProps, }: import("./Components").CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+    TableResults: ({ children, innerProps, manualPagination, }: import("./Components").TableResultProps) => import("react/jsx-runtime").JSX.Element;
+    RowsPerPage: ({ children, innerProps, }: import("./Components").CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+    Pagination: ({ children, innerProps, }: import("./Components").CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+    PaginationNumericButtons: () => import("react/jsx-runtime").JSX.Element;
+    PaginationNumericButton: ({ currentIndex, isSelected, children, innerProps, }: import("./Components").PaginationNumericButtonProps) => import("react/jsx-runtime").JSX.Element;
+    PaginationArrowButton: ({ action, children, innerProps, }: import("./Components").PaginationArrowButtonProps) => import("react/jsx-runtime").JSX.Element;
+    LoadingPlaceholder: ({ children, innerProps, }: import("./Components").CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+    NoDataPlaceholder: ({ children, innerProps, }: import("./Components").CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+    Scrollable: ({ children, innerProps }: import("./Components").CommonInnerProps<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+};
+declare enum BorderStyleEnum {
+    AllSides = "all-sides",
+    Horizontal = "horizontal",
+    None = "none"
+}
+export type BorderStyle = `${BorderStyleEnum}`;
+declare enum HeaderStyleEnum {
+    Filled = "filled",
+    Clean = "clean"
+}
+export type HeaderStyle = `${HeaderStyleEnum}`;
+export type DataGridProps<T extends RowData> = {
+    styling?: Partial<{
+        /** Alternate the background colour of rows */
+        zebraStriping: boolean;
+        /** Type of border that will be used */
+        borderStyle: BorderStyle;
+        /** If header should have styles or not (Aura example) */
+        headerStyle: HeaderStyle;
+    }>;
+    /** Resizing the width of columns */
+    isResizable?: boolean;
+    /** Enables table's loading state */
+    isLoading?: boolean;
+    /**
+     * Enables keyboard navigation.
+     * To control keyboard navigation programmatically
+     * for edge cases, pass a `ref` to `tableNavRef`
+     * @see {@link https://github.com/konsalex/table-nav }
+     */
+    isKeyboardNavigable?: boolean;
+    /**
+     * Reference to the tableNav instance
+     * for programmatic control
+     * @see {@link https://github.com/konsalex/table-nav }
+     */
+    tableNavRef?: React.RefObject<any>;
+    /** Table instance created from `useTable`*/
+    tableInstance: DataGridType<T>;
+    /** Table sub-component overrides */
+    components?: DataGridComponentsInterface<T>;
+    /** Root `div` props */
+    rootProps?: ElementBase<HTMLDivElement>;
+};
+declare const DataGrid: <T extends unknown>(props: DataGridProps<T> & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null;
+export default DataGrid;

package/lib/types/data-grid/DataGridContext.d.ts

@@ -0,0 +1,62 @@
+/**
+ *
+ *  Copyright (c) "Neo4j"
+ *  Neo4j Sweden AB [http://neo4j.com]
+ *
+ *  This file is part of Neo4j.
+ *
+ *  Neo4j is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/// <reference types="react" />
+import type { RowData, Table as DataGridType } from '@tanstack/react-table';
+import { type Body, type BodyCell, type BodyRow, type TableResults, type ResizingBar, type Navigation, type Header, type Pagination, type NoDataPlaceholder, type LoadingPlaceholder, type PaginationNumericButtons, type PaginationNumericButton, type HeaderCell, type PaginationArrowButton, type RowsPerPage, type ActionButton, type ColumnControls, type Scrollable } from './Components';
+type Nullable<T> = T | null;
+export interface DataGridComponentsInterface<T extends RowData> {
+    ResizingBar?: Nullable<typeof ResizingBar<T>>;
+    /**
+     * Header Section
+     */
+    Header?: Nullable<typeof Header>;
+    HeaderCell?: Nullable<typeof HeaderCell<T>>;
+    ActionButton?: Nullable<typeof ActionButton>;
+    ColumnControls?: Nullable<typeof ColumnControls>;
+    /**
+     * Body Section
+     */
+    Scrollable?: Nullable<typeof Scrollable>;
+    Body?: Nullable<typeof Body>;
+    BodyCell?: Nullable<typeof BodyCell<T>>;
+    BodyRow?: Nullable<typeof BodyRow<T>>;
+    LoadingPlaceholder?: Nullable<typeof LoadingPlaceholder>;
+    NoDataPlaceholder?: Nullable<typeof NoDataPlaceholder>;
+    /**
+     * Navigation Section
+     */
+    Navigation?: Nullable<typeof Navigation>;
+    Pagination?: Nullable<typeof Pagination>;
+    PaginationArrowButton?: Nullable<typeof PaginationArrowButton>;
+    TableResults?: Nullable<typeof TableResults>;
+    RowsPerPage?: Nullable<typeof RowsPerPage>;
+    PaginationNumericButtons?: Nullable<typeof PaginationNumericButtons>;
+    PaginationNumericButton?: Nullable<typeof PaginationNumericButton>;
+}
+export interface DataGridContextType<T extends RowData> {
+    resizable: boolean;
+    tableProps: DataGridType<T>;
+    components: DataGridComponentsInterface<T>;
+    loading: boolean;
+}
+export declare const DataGridContext: import("react").Context<DataGridContextType<any>>;
+export declare function useDataGridContext<T extends RowData>(): DataGridContextType<T>;
+export {};

package/lib/types/{table-deprecated → data-grid}/helpers.d.ts

@@ -18,24 +18,7 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-/// <reference types="react" />
-import { type TableResizerProps } from 'react-table';
-/**
- *
- * React Table helper to display sorting icon
- * Source:
- * https://react-table.tanstack.com/docs/api/useSortBy#column-properties
- *
- */
-export declare const SortIcon: ({ isSortedDesc, ...props }: {
-    isSortedDesc: boolean | undefined;
-}) => import("react/jsx-runtime").JSX.Element;
-export declare const ResizingBar: import("react").NamedExoticComponent<TableResizerProps>;
-/**
- * The left section of the bottom navigation
- * that is showing the current page and how many results we can see
- */
-export declare const TableResults: ({ pageIndex, pageLength, rowsLength, }: Record<'pageIndex' | 'pageLength' | 'rowsLength', number>) => import("react/jsx-runtime").JSX.Element;
+import { type Table, type ColumnDef } from '@tanstack/react-table';
 /**
  * Modified from here: https://gist.github.com/kottenator/9d936eb3e4e3c3e02598
  *
@@ -45,7 +28,18 @@ export declare const TableResults: ({ pageIndex, pageLength, rowsLength, }: Reco
  */
 export declare const userFriendlyPagination: (current: number, max: number) => (string | number)[];
 /**
- * Small helper to get handle the Checkbox
- * functionality in tables
+ * Simple helper to generate inline grid style
+ * to be responsive.
+ *
+ * Secret sauce:
+ * The last element takes an "auto" width, so it will
+ * fill the available space, and the result till be for 4 columns:
+ * minmax(min column1Sizepx,column1Sizepx) minmax(min column2Sizepx,column2Sizepx) ... minmax(columnNSizepx, auto)
+ */
+export declare const gridGenerator: <T extends unknown>(table: Table<T>) => string;
+/**
+ * Check if the column is size constrained,
+ * so we can let the column's width grow with `flex-grow: 1`
+ * @param columnDef
  */
-export declare const toggleRowSelection: (list: number[], idx: number) => number[];
+export declare const isSizeConstrained: <T extends unknown>(columnDef: ColumnDef<T>) => boolean;

package/lib/types/{table-deprecated/hooks → data-grid}/index.d.ts

@@ -18,6 +18,8 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-export * from './useMultiRowSelect';
-export * from './useSingleRowSelect';
-export * from './hookCallbackTypes';
+export { default as DataGrid, DataGridComponents } from './DataGrid';
+import * as dataGridUtils from './helpers';
+import { useDataGridContext } from './DataGridContext';
+export { dataGridUtils, useDataGridContext };
+export type * from './datagrid-types';

package/lib/types/dialog/Dialog.d.ts

@@ -38,7 +38,7 @@ export interface DialogProps extends Omit<ModalProps, 'onClose'> {
     onClose?: (e: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>, reason?: DialogCloseReason) => void;
 }
 export declare const Dialog: {
-    ({ open, onClose, children, type, className, size, disableCloseButton, ...rest }: DialogProps): import("react/jsx-runtime").JSX.Element | null;
+    ({ open, onClose, children, type, size, disableCloseButton, ...restProps }: DialogProps): import("react/jsx-runtime").JSX.Element | null;
     Actions: ({ children, className, ...rest }: DialogActionsProps) => import("react/jsx-runtime").JSX.Element;
     Header: ({ children, className, ...rest }: DialogHeaderProps) => import("react/jsx-runtime").JSX.Element;
     Subtitle: ({ children, className, ...rest }: DialogSubtitleProps) => import("react/jsx-runtime").JSX.Element;

package/lib/types/{drag-and-drop/DragAndDrop.d.ts → dropzone/Dropzone.d.ts}

@@ -28,7 +28,7 @@ import { type ElementBase } from '../helpers';
  *
  *
  */
-export interface DragAndDropProps extends ElementBase<HTMLDivElement> {
+export interface DropzoneProps extends ElementBase<HTMLDivElement> {
     /**
      *  See here - https://react-dropzone.js.org/#src. Don't use 'accept'
      *  if using custom file extensions as this option is broken.
@@ -39,7 +39,7 @@ export interface DragAndDropProps extends ElementBase<HTMLDivElement> {
     supportedFilesDescription?: React.ReactNode | string;
     /** Element to display when uploading the file. When passed, drag&drop zone is disabled */
     loadingComponent?: React.ReactNode | string;
-    /** To be used when want to test loadingComponent UI without actualy draging and uploading the files */
+    /** To be used when want to test loadingComponent UI without actually dragging and uploading the files */
     isTesting?: boolean;
     /** Use when wanting a custom title. */
     customTitle?: React.ReactNode | string;
@@ -48,12 +48,5 @@ export interface DragAndDropProps extends ElementBase<HTMLDivElement> {
     /** The accepted file extensions for the Drag-and-Drop. */
     acceptedFileExtensions?: string[];
 }
-/**
- *
- *
- * DragAndDrop Component
- *
- *
- */
-declare const DragAndDrop: (props: DragAndDropProps) => import("react/jsx-runtime").JSX.Element;
-export default DragAndDrop;
+declare const Dropzone: (props: DropzoneProps) => import("react/jsx-runtime").JSX.Element;
+export default Dropzone;

package/lib/types/{drag-and-drop → dropzone}/index.d.ts

@@ -18,4 +18,4 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-export { default as DragAndDrop } from './DragAndDrop';
+export { default as Dropzone } from './Dropzone';

package/lib/types/helpers/forwardRef.d.ts

@@ -21,4 +21,10 @@
 import { type ForwardedRef, type ReactElement, type RefAttributes } from 'react';
 type ForwardRefType = <T, P = Record<string, never>>(render: (props: P, ref: ForwardedRef<T>) => ReactElement | null) => (props: P & RefAttributes<T>) => ReactElement | null;
 export declare const forwardRef: ForwardRefType;
+/**
+ * This type is to help retain the ForwardRefExoticComponent properties
+ * on a component when using our own custom  generic forwardRef function.
+ * This type can be removed when our custom generic forwardRef is removed.
+ */
+export type RetainForwardRefProps<T> = React.ForwardRefExoticComponent<T & React.RefAttributes<unknown>>;
 export {};

package/lib/types/index.d.ts

@@ -32,17 +32,18 @@ export * from './dialog';
 export * from './modal';
 export * from './loading-spinner';
 export * from './tabs';
-export * from './view-selector';
+export * from './segmented-control';
 export * from './popover';
 export * from './progress-bar';
-export * from './table-deprecated';
 export * from './table';
-export * from './drag-and-drop';
+export * from './dropzone';
+export * from './data-grid';
 export * from './text-input';
 export * from './textarea';
 export * from './text-link';
 export * from './dropdown';
 export * from './tag';
+export * from './theme';
 export * from './widget';
 export * from './wizard';
 export * from './graph-label';

package/lib/types/modal/Modal.d.ts

@@ -18,18 +18,25 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-import React from 'react';
-import { type ElementBase } from '../helpers';
+import React, { type ComponentPropsWithoutRef } from 'react';
 export declare enum ModalCloseReason {
     BACKDROP_CLICK = "backdropClick",
     ESCAPE_KEY_DOWN = "escapeKeyDown"
 }
-export interface ModalProps extends ElementBase {
+export interface ModalProps {
     open: boolean;
     children: React.ReactNode;
-    size?: 'small' | 'medium' | 'large';
-    className?: string;
+    /**
+     * We provide convenient default sizes for the modal,
+     * but you can also set your own size, when providing
+     * `unset` to the `size` prop.
+     */
+    size?: 'small' | 'medium' | 'large' | 'unset';
     container?: Element;
     onClose?: (e: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>, reason?: ModalCloseReason) => void;
+    /** Forwards the props to the modal container's wrapper - use with caution */
+    rootProps?: ComponentPropsWithoutRef<'div'>;
+    /** Forwards the props to the modal container */
+    modalProps?: ComponentPropsWithoutRef<'div'>;
 }
-export declare const Modal: ({ open, size, onClose, children, className, container, ...rest }: ModalProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const Modal: React.ForwardRefExoticComponent<ModalProps & React.RefAttributes<HTMLDivElement>>;

package/lib/types/popover/Popover.d.ts

@@ -18,7 +18,8 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-import React from 'react';
+import React, { type ComponentProps } from 'react';
+import FocusLock from 'react-focus-lock';
 /**
  * A modified version of the Material UI (@mui/material) Popover component.
  * We use a modified/slimmed version for easier maintenance.
@@ -70,7 +71,7 @@ export interface PopoverProps extends ElementBase {
     onClose?: (e: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
     /** Additional classes */
     className?: string;
-    /** Whether or not the menu is nested. IE is this menu a sub menu */
+    /** Whether the menu is nested. IE is this menu a sub menu */
     nested?: boolean;
     /** Disable backdrop -  Allows event capturing - and pointer events to pass to elements below */
     disableBackdrop?: boolean;
@@ -78,6 +79,11 @@ export interface PopoverProps extends ElementBase {
     anchorPortal?: boolean;
     /** If the popover should constrain the focus inside the popover while open */
     captureFocus?: boolean;
+    /**
+     * Props to pass to the FocusLock component
+     * @see https://github.com/theKashey/react-focus-lock
+     */
+    focusLockProps?: ComponentProps<typeof FocusLock>;
 }
 export declare const Popover: React.ForwardRefExoticComponent<Omit<PopoverProps, "ref"> & React.RefAttributes<unknown>>;
 export {};

package/lib/types/{view-selector/ViewSelector.d.ts → segmented-control/SegmentedControl.d.ts}

@@ -20,32 +20,26 @@
  */
 import React from 'react';
 import { type ElementBase } from '../helpers';
-/**
- *
- *
- * Types
- *
- *
- */
-type ViewSelectorID = string | number;
-export interface ViewSelectorProps<T extends ViewSelectorID> extends ElementBase {
+type SegmentedControlID = string | number;
+export interface SegmentedControlProps<T extends SegmentedControlID> extends ElementBase {
     /** Size of the selector */
     size?: 'small' | 'large';
-    /** If selector items will include only icons */
-    icons?: boolean;
+    /** If selector items will include only icons (makes controls rectangular) */
+    hasOnlyIcons?: boolean;
     /**
      * onChange function is more generic to support union type of strings as input
-     * to help useState in components that uses Switch group with typesafety
+     * to help useState in components that uses Switch group with type-safety
      */
     onChange: (e: T) => void | ((e: React.SetStateAction<T>) => void);
     /** Currently selected option */
     selected: T;
     children: React.ReactNode | string;
 }
-export declare const ViewSelector: <T extends ViewSelectorID>(props: ViewSelectorProps<T> & React.RefAttributes<unknown>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-export declare const ViewSelectorItem: React.ForwardRefExoticComponent<Omit<React.HTMLProps<HTMLElement>, "as" | "selected" | "size" | "onChange" | "ref"> & {
-    as?: string | React.ComponentType<any> | undefined;
-} & {
-    value: string;
-} & React.RefAttributes<unknown>>;
-export {};
+declare const SegmentedControl: (<T extends SegmentedControlID>(props: SegmentedControlProps<T> & React.RefAttributes<unknown>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null) & {
+    Item: React.ForwardRefExoticComponent<Omit<React.HTMLProps<HTMLElement>, "as" | "selected" | "size" | "onChange" | "ref"> & {
+        as?: string | React.ComponentType<any> | undefined;
+    } & {
+        value: string;
+    } & React.RefAttributes<unknown>>;
+};
+export { SegmentedControl };

package/lib/{esm/table-deprecated/hooks/hookCallbackTypes.js → types/segmented-control/index.d.ts}

@@ -18,5 +18,4 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-export {};
-//# sourceMappingURL=hookCallbackTypes.js.map
+export * from './SegmentedControl';