simple-table-core 0.6.7 → 0.6.8

package/dist/components/Animate.d.ts

@@ -0,0 +1,17 @@
+import React, { RefObject } from "react";
+import HeaderObject from "../types/HeaderObject";
+export declare const TEST_KEY = "productId";
+interface AnimateProps {
+    allowHorizontalAnimate?: boolean;
+    children: React.ReactNode | React.ReactNode[];
+    draggedHeaderRef?: RefObject<HeaderObject | null>;
+    headersRef: RefObject<HeaderObject[]>;
+    isBody?: boolean;
+    mainBodyRef: RefObject<HTMLDivElement | null>;
+    pauseAnimation?: boolean;
+    rowIndex: number;
+}
+declare const AnimateWrapper: ({ allowAnimations, children, ...props }: AnimateProps & {
+    allowAnimations: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default AnimateWrapper;

package/dist/components/Checkbox.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from "react";
+interface CheckboxProps {
+    checked?: boolean;
+    children?: ReactNode;
+    onChange?: (checked: boolean) => void;
+}
+declare const Checkbox: ({ checked, children, onChange }: CheckboxProps) => import("react/jsx-runtime").JSX.Element;
+export default Checkbox;

package/dist/components/SimpleTable/EditableCell/BooleanEdit.d.ts

@@ -0,0 +1,7 @@
+interface BooleanSelectProps {
+    value: boolean;
+    onBlur: () => void;
+    onChange: (value: boolean) => void;
+}
+declare const BooleanSelect: ({ value, onBlur, onChange }: BooleanSelectProps) => import("react/jsx-runtime").JSX.Element;
+export default BooleanSelect;

package/dist/components/SimpleTable/EditableCell/EditableCell.d.ts

@@ -0,0 +1,8 @@
+import CellValue from "../../../types/CellValue";
+interface EditableCellProps {
+    onChange: (newValue: CellValue) => void;
+    setIsEditing: (isEditing: boolean) => void;
+    value: CellValue;
+}
+declare const EditableCell: ({ onChange, setIsEditing, value }: EditableCellProps) => import("react/jsx-runtime").JSX.Element;
+export default EditableCell;

package/dist/components/SimpleTable/EditableCell/NumberEdit.d.ts

@@ -0,0 +1,7 @@
+interface NumberInputProps {
+    defaultValue: number;
+    onBlur: () => void;
+    onChange: (value: string) => void;
+}
+declare const NumberEdit: ({ defaultValue, onBlur, onChange }: NumberInputProps) => import("react/jsx-runtime").JSX.Element;
+export default NumberEdit;

package/dist/components/SimpleTable/EditableCell/StringEdit.d.ts

@@ -0,0 +1,7 @@
+interface TextInputProps {
+    defaultValue: string | null | undefined;
+    onBlur: () => void;
+    onChange: (value: string) => void;
+}
+declare const StringEdit: ({ defaultValue, onBlur, onChange }: TextInputProps) => import("react/jsx-runtime").JSX.Element;
+export default StringEdit;

package/dist/components/SimpleTable/PinnedLeftColumns.d.ts

@@ -0,0 +1,2 @@
+declare const PinnedLeftColumns: () => import("react/jsx-runtime").JSX.Element;
+export default PinnedLeftColumns;

package/dist/components/SimpleTable/PinnedRightColumns.d.ts

@@ -0,0 +1,2 @@
+declare const PinnedRightColumns: () => import("react/jsx-runtime").JSX.Element;
+export default PinnedRightColumns;

package/dist/components/SimpleTable/RenderCells.d.ts

@@ -0,0 +1,16 @@
+import Row from "../../types/Row";
+import HeaderObject from "../../types/HeaderObject";
+import TableBodyProps from "../../types/TableBodyProps";
+declare const RenderCells: ({ getBorderClass, handleMouseDown, handleMouseOver, headers, hiddenColumns, isRowExpanded, isSelected, isTopLeftCell, lastGroupRow, onExpandRowClick, pinned, row, rowIndex, shouldDisplayLastColumnCell, ...props }: {
+    depth: number;
+    headers: HeaderObject[];
+    hiddenColumns: Record<string, boolean>;
+    isRowExpanded: (rowId: string | number) => boolean;
+    lastGroupRow?: boolean | undefined;
+    onExpandRowClick: (rowIndex: number) => void;
+    pinned?: "left" | "right" | undefined;
+    row: Row;
+    rowIndex: number;
+    shouldDisplayLastColumnCell: boolean;
+} & Omit<TableBodyProps, "currentRows" | "headerContainerRef">) => import("react/jsx-runtime").JSX.Element;
+export default RenderCells;

package/dist/components/SimpleTable/SimpleTable.d.ts

@@ -0,0 +1,60 @@
+import { ReactNode } from "react";
+import HeaderObject from "../../types/HeaderObject";
+import CellChangeProps from "../../types/CellChangeProps";
+import "../../styles/simple-table.css";
+import Theme from "../../types/Theme";
+import Row from "../../types/Row";
+declare enum ColumnEditorPosition {
+    Left = "left",
+    Right = "right"
+}
+interface SimpleTableProps {
+    allowAnimations?: boolean;
+    columnEditorPosition?: ColumnEditorPosition;
+    columnEditorText?: string;
+    columnResizing?: boolean;
+    defaultHeaders: HeaderObject[];
+    draggable?: boolean;
+    editColumns?: boolean;
+    editColumnsInitOpen?: boolean;
+    height?: string;
+    hideFooter?: boolean;
+    nextIcon?: ReactNode;
+    onCellChange?: ({ accessor, newValue, originalRowIndex, row }: CellChangeProps) => void;
+    prevIcon?: ReactNode;
+    rows: Row[];
+    rowsPerPage?: number;
+    selectableCells?: boolean;
+    selectableColumns?: boolean;
+    shouldPaginate?: boolean;
+    sortDownIcon?: ReactNode;
+    sortUpIcon?: ReactNode;
+    theme?: Theme;
+}
+declare const _default: import("react").MemoExoticComponent<{
+    ({ allowAnimations, columnEditorPosition, columnEditorText, columnResizing, defaultHeaders, draggable, editColumns, editColumnsInitOpen, height, hideFooter, nextIcon, onCellChange, prevIcon, rows, rowsPerPage, selectableCells, selectableColumns, shouldPaginate, sortDownIcon, sortUpIcon, theme, }: SimpleTableProps): import("react/jsx-runtime").JSX.Element;
+    defaultProps: {
+        allowAnimations: boolean;
+        columnEditorPosition: ColumnEditorPosition;
+        columnEditorText: string;
+        columnResizing: boolean;
+        defaultHeaders: never[];
+        draggable: boolean;
+        editColumns: boolean;
+        editColumnsInitOpen: boolean;
+        height: string;
+        hideFooter: boolean;
+        nextIcon: import("react/jsx-runtime").JSX.Element;
+        onCellChange: () => void;
+        prevIcon: import("react/jsx-runtime").JSX.Element;
+        rows: never[];
+        rowsPerPage: number;
+        selectableCells: boolean;
+        selectableColumns: boolean;
+        shouldPaginate: boolean;
+        sortDownIcon: import("react/jsx-runtime").JSX.Element;
+        sortUpIcon: import("react/jsx-runtime").JSX.Element;
+        theme: string;
+    };
+}>;
+export default _default;

package/dist/components/SimpleTable/TableBody.d.ts

@@ -0,0 +1,3 @@
+import TableBodyProps from "../../types/TableBodyProps";
+declare const TableBody: (props: TableBodyProps) => import("react/jsx-runtime").JSX.Element;
+export default TableBody;

package/dist/components/SimpleTable/TableCell.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import TableCellProps from "../../types/TableCellProps";
+declare const TableCell: import("react").ForwardRefExoticComponent<TableCellProps & import("react").RefAttributes<HTMLDivElement>>;
+export default TableCell;

package/dist/components/SimpleTable/TableColumnEditor/TableColumnEditor.d.ts

@@ -0,0 +1,17 @@
+import { Dispatch, SetStateAction } from "react";
+import HeaderObject from "../../../types/HeaderObject";
+type TableColumnEditorProps = {
+    headers: HeaderObject[];
+    columnEditorText: string;
+    editColumns: boolean;
+    editColumnsInitOpen: boolean;
+    position: "left" | "right";
+    setHiddenColumns: Dispatch<SetStateAction<{
+        [key: string]: boolean;
+    }>>;
+    hiddenColumns: {
+        [key: string]: boolean;
+    };
+};
+declare const TableColumnEditor: ({ columnEditorText, editColumns, editColumnsInitOpen, headers, position, setHiddenColumns, hiddenColumns, }: TableColumnEditorProps) => import("react/jsx-runtime").JSX.Element | null;
+export default TableColumnEditor;

package/dist/components/SimpleTable/TableColumnEditor/TableColumnEditorPopout.d.ts

@@ -0,0 +1,16 @@
+import { Dispatch, SetStateAction } from "react";
+import HeaderObject from "../../../types/HeaderObject";
+type TableColumnEditorPopoutProps = {
+    headers: HeaderObject[];
+    open: boolean;
+    position: "left" | "right";
+    setOpen: (open: boolean) => void;
+    setHiddenColumns: Dispatch<SetStateAction<{
+        [key: string]: boolean;
+    }>>;
+    hiddenColumns: {
+        [key: string]: boolean;
+    };
+};
+declare const TableColumnEditorPopout: ({ headers, open, position, setOpen, setHiddenColumns, hiddenColumns, }: TableColumnEditorPopoutProps) => import("react/jsx-runtime").JSX.Element;
+export default TableColumnEditorPopout;

package/dist/components/SimpleTable/TableContent.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from "react";
+import TableBodyProps from "../../types/TableBodyProps";
+import TableHeaderProps from "../../types/TableHeaderProps";
+type OmittedTableProps = "headerContainerRef" | "shouldDisplayLastColumnCell" | "pinnedLeftColumns" | "pinnedRightColumns" | "mainTemplateColumns" | "pinnedLeftTemplateColumns" | "pinnedRightTemplateColumns";
+interface TableContentProps extends Omit<TableHeaderProps, OmittedTableProps>, Omit<TableBodyProps, OmittedTableProps> {
+    editColumns: boolean;
+    pinnedLeftRef: RefObject<HTMLDivElement | null>;
+    pinnedRightRef: RefObject<HTMLDivElement | null>;
+    isRowExpanded: (rowId: string | number) => boolean;
+    onExpandRowClick: (rowIndex: number) => void;
+}
+declare const TableContent: ({ allowAnimations, columnResizing, currentRows, draggable, draggedHeaderRef, editColumns, forceUpdate, getBorderClass, handleMouseDown, handleMouseOver, headersRef, hiddenColumns, hoveredHeaderRef, isRowExpanded, isSelected, isTopLeftCell, isWidthDragging, mainBodyRef, onCellChange, onExpandRowClick, onSort, onTableHeaderDragEnd, pinnedLeftRef, pinnedRightRef, scrollbarHorizontalRef, scrollbarWidth, selectableColumns, setIsWidthDragging, setSelectedCells, shouldPaginate, sort, sortDownIcon, sortUpIcon, tableBodyContainerRef, }: TableContentProps) => import("react/jsx-runtime").JSX.Element;
+export default TableContent;

package/dist/components/SimpleTable/TableFooter.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from "react";
+interface TableFooterProps {
+    currentPage: number;
+    hideFooter?: boolean;
+    nextIcon?: ReactNode;
+    onPageChange: (page: number) => void;
+    prevIcon?: ReactNode;
+    rowsPerPage: number;
+    shouldPaginate?: boolean;
+    totalRows: number;
+}
+declare const TableFooter: ({ currentPage, hideFooter, nextIcon, onPageChange, prevIcon, rowsPerPage, shouldPaginate, totalRows, }: TableFooterProps) => import("react/jsx-runtime").JSX.Element | null;
+export default TableFooter;

package/dist/components/SimpleTable/TableHeader.d.ts

@@ -0,0 +1,3 @@
+import TableHeaderProps from "../../types/TableHeaderProps";
+declare const TableHeader: ({ allowAnimations, columnResizing, currentRows, draggable, draggedHeaderRef, forceUpdate, headerContainerRef, headersRef, hiddenColumns, hoveredHeaderRef, isWidthDragging, mainTemplateColumns, onSort, onTableHeaderDragEnd, pinnedLeftColumns, pinnedLeftTemplateColumns, pinnedRightColumns, pinnedRightTemplateColumns, selectableColumns, setIsWidthDragging, setSelectedCells, shouldDisplayLastColumnCell, sort, sortDownIcon, sortUpIcon, mainBodyRef, }: TableHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export default TableHeader;

package/dist/components/SimpleTable/TableHeaderCell.d.ts

@@ -0,0 +1,26 @@
+import { SetStateAction, Dispatch, ReactNode } from "react";
+import HeaderObject from "../../types/HeaderObject";
+import SortConfig from "../../types/SortConfig";
+import OnSortProps from "../../types/OnSortProps";
+import Row from "../../types/Row";
+interface TableHeaderCellProps {
+    columnResizing: boolean;
+    currentRows: Row[];
+    draggable: boolean;
+    draggedHeaderRef: React.MutableRefObject<HeaderObject | null>;
+    forceUpdate: () => void;
+    headersRef: React.RefObject<HeaderObject[]>;
+    hoveredHeaderRef: React.MutableRefObject<HeaderObject | null>;
+    index: number;
+    onSort: OnSortProps;
+    onTableHeaderDragEnd: (newHeaders: HeaderObject[]) => void;
+    reverse?: boolean;
+    selectableColumns: boolean;
+    setIsWidthDragging: Dispatch<SetStateAction<boolean>>;
+    setSelectedCells: Dispatch<React.SetStateAction<Set<string>>>;
+    sort: SortConfig | null;
+    sortDownIcon?: ReactNode;
+    sortUpIcon?: ReactNode;
+}
+declare const TableHeaderCell: import("react").ForwardRefExoticComponent<TableHeaderCellProps & import("react").RefAttributes<HTMLDivElement>>;
+export default TableHeaderCell;

package/dist/components/SimpleTable/TableHorizontalScrollbar.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from "react";
+import HeaderObject from "../../types/HeaderObject";
+declare const TableHorizontalScrollbar: ({ headersRef, mainBodyRef, pinnedLeftRef, pinnedRightRef, scrollbarHorizontalRef, tableContentWidth, }: {
+    headersRef: RefObject<HeaderObject[]>;
+    mainBodyRef: RefObject<HTMLDivElement | null>;
+    pinnedLeftRef: RefObject<HTMLDivElement | null>;
+    pinnedRightRef: RefObject<HTMLDivElement | null>;
+    scrollbarHorizontalRef: RefObject<HTMLDivElement | null>;
+    tableContentWidth: number;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default TableHorizontalScrollbar;

package/dist/components/SimpleTable/TableLastColumnCell.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+declare const TableLastColumnCell: import("react").ForwardRefExoticComponent<{
+    visible: boolean;
+} & import("react").RefAttributes<unknown>>;
+export default TableLastColumnCell;

package/dist/components/SimpleTable/TableRow.d.ts

@@ -0,0 +1,14 @@
+import Row from "../../types/Row";
+import TableBodyProps from "../../types/TableBodyProps";
+declare const TableRow: ({ depth, getNextRowIndex, index, lastGroupRow, pinned, props, row, }: {
+    depth?: number | undefined;
+    getNextRowIndex: () => number;
+    index: number;
+    lastGroupRow?: boolean | undefined;
+    pinned?: "left" | "right" | undefined;
+    props: Omit<TableBodyProps, "currentRows" | "headerContainerRef"> & {
+        onExpandRowClick: (rowIndex: number) => void;
+    };
+    row: Row;
+}) => import("react/jsx-runtime").JSX.Element;
+export default TableRow;

package/dist/components/SimpleTable/TableRowSeparator.d.ts

@@ -0,0 +1,4 @@
+declare const TableRowSeparator: ({ lastGroupRow }: {
+    lastGroupRow?: boolean | undefined;
+}) => import("react/jsx-runtime").JSX.Element;
+export default TableRowSeparator;

package/dist/components/SimpleTable/TableSection.d.ts

@@ -0,0 +1,13 @@
+import Row from "../../types/Row";
+import { RefObject } from "react";
+import TableBodyProps from "../../types/TableBodyProps";
+declare const TableSection: ({ headerContainerRef, isRowExpanded, onExpandRowClick, pinned, rows, sectionRef, templateColumns, ...props }: {
+    headerContainerRef: RefObject<HTMLDivElement | null>;
+    isRowExpanded: (rowId: string | number) => boolean;
+    onExpandRowClick: (rowIndex: number) => void;
+    pinned?: "left" | "right" | undefined;
+    rows: Row[];
+    sectionRef?: RefObject<HTMLDivElement | null> | undefined;
+    templateColumns: string;
+} & Omit<TableBodyProps, "currentRows">) => import("react/jsx-runtime").JSX.Element;
+export default TableSection;

package/dist/consts/general-consts.d.ts

@@ -0,0 +1 @@
+export declare const DRAG_THROTTLE_LIMIT = 50;

package/dist/context/TableContext.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import Row from "../types/Row";
+declare const TableContext: import("react").Context<{
+    rows: Row[];
+    tableRows: Row[];
+}>;
+export default TableContext;

package/dist/helpers/calculateBoundingBoxes.d.ts

@@ -0,0 +1,11 @@
+import { MutableRefObject } from "react";
+import BoundingBox from "../types/BoundingBox";
+import HeaderObject from "../types/HeaderObject";
+declare const calculateBoundingBoxes: ({ currentHeaders, draggedHeaderRef, rowIndex, }: {
+    currentHeaders: HeaderObject[];
+    draggedHeaderRef?: MutableRefObject<HeaderObject | null> | undefined;
+    rowIndex: number;
+}) => {
+    [key: string]: false | BoundingBox;
+};
+export default calculateBoundingBoxes;

package/dist/helpers/shuffleArray.d.ts

@@ -0,0 +1 @@
+export default function shuffleArray(array: any[]): any[];

package/dist/hooks/useDragHandler.d.ts

@@ -0,0 +1,12 @@
+import { DragEvent } from "react";
+import HeaderObject from "../types/HeaderObject";
+import DragHandlerProps from "../types/DragHandlerProps";
+declare const useDragHandler: ({ draggedHeaderRef, headersRef, hoveredHeaderRef, onTableHeaderDragEnd, }: DragHandlerProps) => {
+    handleDragStart: (header: HeaderObject) => void;
+    handleDragOver: ({ event, hoveredHeader, }: {
+        event: DragEvent<HTMLDivElement>;
+        hoveredHeader: HeaderObject;
+    }) => void;
+    handleDragEnd: () => void;
+};
+export default useDragHandler;

package/dist/hooks/usePrevious.d.ts

@@ -0,0 +1,2 @@
+declare const usePrevious: <T>(value: T) => T;
+export default usePrevious;

package/dist/hooks/useScrollSync.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from "react";
+declare const useScrollSync: (sourceRef: RefObject<HTMLElement | null>, targetRef: RefObject<HTMLElement | null>) => void;
+export default useScrollSync;

package/dist/hooks/useScrollbarVisibility.d.ts

@@ -0,0 +1,8 @@
+import { RefObject } from "react";
+declare const useScrollbarVisibility: ({ headerContainerRef, mainSectionRef, scrollbarHorizontalRef, scrollbarWidth, }: {
+    headerContainerRef?: RefObject<HTMLElement | null> | undefined;
+    mainSectionRef?: RefObject<HTMLElement | null> | undefined;
+    scrollbarHorizontalRef?: RefObject<HTMLElement | null> | undefined;
+    scrollbarWidth: number;
+}) => void;
+export default useScrollbarVisibility;

package/dist/hooks/useSelection.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import HeaderObject from "../types/HeaderObject";
+export type MouseDownProps = {
+    rowIndex: number;
+    colIndex: number;
+};
+declare const useSelection: ({ selectableCells, headers, rows, }: {
+    selectableCells: boolean;
+    headers: HeaderObject[];
+    rows: {
+        [key: string]: any;
+    }[];
+}) => {
+    selectedCells: Set<string>;
+    handleMouseDown: ({ colIndex, rowIndex }: MouseDownProps) => void;
+    handleMouseOver: (rowIndex: number, colIndex: number) => void;
+    handleMouseUp: () => void;
+    isSelected: (rowIndex: number, colIndex: number) => boolean;
+    getBorderClass: (rowIndex: number, colIndex: number) => string;
+    isTopLeftCell: (rowIndex: number, colIndex: number) => boolean;
+    setSelectedCells: import("react").Dispatch<import("react").SetStateAction<Set<string>>>;
+};
+export default useSelection;

package/dist/hooks/useSortableData.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import HeaderObject from "../types/HeaderObject";
+import Row from "../types/Row";
+import SortConfig from "../types/SortConfig";
+declare const useSortableData: (tableRows: Row[], headers: HeaderObject[]) => {
+    sort: SortConfig | null;
+    setSort: import("react").Dispatch<import("react").SetStateAction<SortConfig | null>>;
+    sortedRows: Row[];
+    hiddenColumns: Record<string, boolean>;
+    setHiddenColumns: import("react").Dispatch<import("react").SetStateAction<Record<string, boolean>>>;
+};
+export default useSortableData;

package/dist/hooks/useWidthSync.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from "react";
+declare const useWidthSync: ({ callback, ref, widthAttribute, }: {
+    callback: (width: number) => void;
+    ref: RefObject<HTMLElement | null>;
+    widthAttribute: "offsetWidth" | "scrollWidth";
+}) => void;
+export default useWidthSync;

package/dist/icons/AngleDownIcon.d.ts

@@ -0,0 +1,4 @@
+declare const AngleDownIcon: ({ className }: {
+    className?: string | undefined;
+}) => import("react/jsx-runtime").JSX.Element;
+export default AngleDownIcon;

package/dist/icons/AngleLeftIcon.d.ts

@@ -0,0 +1,4 @@
+declare const AngleLeftIcon: ({ className }: {
+    className: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default AngleLeftIcon;

package/dist/icons/AngleRightIcon.d.ts

@@ -0,0 +1,4 @@
+declare const AngleRightIcon: ({ className }: {
+    className: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default AngleRightIcon;

package/dist/icons/AngleUpIcon.d.ts

@@ -0,0 +1,4 @@
+declare const AngleUpIcon: ({ className }: {
+    className?: string | undefined;
+}) => import("react/jsx-runtime").JSX.Element;
+export default AngleUpIcon;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import SimpleTable from "./components/SimpleTable/SimpleTable";
+export { SimpleTable };