@monolith-forensics/monolith-ui 1.1.89 → 1.1.91

package/dist/MonolithUIProvider/GlobalStyle.d.ts

@@ -1,3 +1,4 @@
+import "overlayscrollbars/overlayscrollbars.css";
 declare const GlobalStyle: import("react").NamedExoticComponent<import("styled-components").ExecutionProps & {
     theme: any;
 }>;

package/dist/MonolithUIProvider/GlobalStyle.js

@@ -1,4 +1,5 @@
 import { createGlobalStyle } from "styled-components";
+import "overlayscrollbars/overlayscrollbars.css";
 const GlobalStyle = createGlobalStyle `
 
     * {
@@ -50,6 +51,22 @@ const GlobalStyle = createGlobalStyle `
         color: unset;
     }
 
+    // Custom OS scrollbar theme
+    .os-theme-dark {
+        --os-handle-bg: ${(props) => props.theme.scrollbar.thumb};
+        --os-handle-bg-active: ${(props) => props.theme.scrollbar.thumb};
+    }
+
+    .os-theme-light {
+        --os-handle-bg: #e4e4e4;
+        --os-handle-bg-hover: #c6c6c6;
+        --os-handle-bg-active: #c6c6c6;
+
+        &:hover {
+        --os-scrollbar-color: #c6c6c6;
+        }
+    }
+
     ::-webkit-scrollbar {
 	    width: 6px;
 	    height: 5px;

package/dist/NewTable/ActionButton.d.ts

@@ -0,0 +1,4 @@
+declare const ActionButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("../Button").ButtonProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLButtonElement> | null | undefined;
+}, never>> & string & Omit<import("react").ForwardRefExoticComponent<import("../Button").ButtonProps & import("react").RefAttributes<HTMLButtonElement>>, keyof import("react").Component<any, {}, any>>;
+export default ActionButton;

package/dist/NewTable/ActionButton.js

@@ -0,0 +1,11 @@
+import styled from "styled-components";
+import Button from "../Button";
+const ActionButton = styled(Button) `
+  padding: 2px;
+  height: fit-content;
+
+  svg {
+    color: ${({ theme }) => theme.palette.primary.main};
+  }
+`;
+export default ActionButton;

package/dist/NewTable/ActionCell.d.ts

@@ -0,0 +1,4 @@
+declare const ActionCell: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import("./types").TDProps> & import("./types").TDProps, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, never>> & string;
+export default ActionCell;

package/dist/NewTable/ActionCell.js

@@ -0,0 +1,12 @@
+import styled from "styled-components";
+import { TD } from "./TableComponents";
+const ActionCell = styled(TD) `
+  width: 40px;
+  min-width: 40px;
+  max-width: 40px;
+
+  display: flex;
+  justify-content: center;
+  align-items: center;
+`;
+export default ActionCell;

package/dist/NewTable/Column.d.ts

@@ -0,0 +1,3 @@
+import { ColumnProps } from "./types";
+declare const Column: React.FC<ColumnProps>;
+export default Column;

package/dist/NewTable/Column.js

@@ -0,0 +1,5 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+const Column = () => {
+    return _jsx(_Fragment, {});
+};
+export default Column;

package/dist/NewTable/ColumnResizer.d.ts

@@ -0,0 +1,14 @@
+import { ColumnState, onResizeFinishedProps } from "./types";
+declare const ColumnResizer: ({ onResize, onResizeFinished, column, showOnHover, }: {
+    className?: string;
+    onResize?: (e: {
+        columns: {
+            dataField: string;
+            width: number;
+        }[];
+    }) => void;
+    onResizeFinished?: (e: onResizeFinishedProps) => void;
+    column: ColumnState;
+    showOnHover?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ColumnResizer;

package/dist/NewTable/ColumnResizer.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import styled from "styled-components";
+import { resizeHandler } from "./Utils";
+const StyledContainer = styled.div `
+  position: absolute;
+  right: -2px;
+  top: 0;
+  height: 100%;
+  z-index: 1;
+  width: 4px;
+  background-color: ${(props) => props.theme.palette.divider};
+  cursor: col-resize;
+  user-select: none;
+  touch-action: none;
+  opacity: 0;
+
+  &[data-show-on-hover="true"]:hover {
+    opacity: 1;
+    background: ${(props) => props.theme.palette.primary.main};
+  }
+
+  &.isResizing {
+    opacity: 1;
+    background: ${(props) => props.theme.palette.primary.main};
+  }
+`;
+const ColumnResizer = ({ onResize = () => { }, onResizeFinished, column, showOnHover = false, }) => {
+    return (_jsx(StyledContainer, { className: `resizer col-${column.columnId}`, "data-show-on-hover": showOnHover, onClick: (e) => {
+            e.stopPropagation();
+            e.nativeEvent.stopImmediatePropagation();
+            e.preventDefault();
+        }, onMouseDown: (e) => {
+            e.stopPropagation();
+            e.nativeEvent.stopImmediatePropagation();
+            e.preventDefault();
+            resizeHandler({
+                event: e,
+                columnId: column.columnId,
+                columnProps: column,
+                onResize: onResize,
+                onResizeFinished: onResizeFinished,
+            });
+        } }));
+};
+export default ColumnResizer;

package/dist/NewTable/SelectionCell.d.ts

@@ -0,0 +1,4 @@
+declare const SelectionCell: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import("./types").TDProps> & import("./types").TDProps, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, never>> & string;
+export default SelectionCell;

package/dist/NewTable/SelectionCell.js

@@ -0,0 +1,12 @@
+import styled from "styled-components";
+import { TD } from "./TableComponents";
+const SelectionCell = styled(TD) `
+  width: 40px;
+  min-width: 40px;
+  max-width: 40px;
+
+  display: flex;
+  justify-content: center;
+  align-items: center;
+`;
+export default SelectionCell;

package/dist/NewTable/StateStorage.d.ts

@@ -0,0 +1,18 @@
+import { ColumnState, SelectionState, SortState, TableState } from "./types";
+type GetTableStateFn = (key: string) => TableState;
+type GetColumnStateFn = (key: string) => ColumnState[];
+type SetColumneStateFn = (key: string, value: ColumnState[]) => void;
+type GetSelectionStateFn = (key: string) => SelectionState;
+type SetSelectionStateFn = (key: string, value: any) => void;
+type GetSortStateStateFn = (key: string) => SortState | null | undefined;
+type SetSortStateFn = (key: string, value: SortState | undefined | null) => void;
+declare const StateStorage: {
+    getTableState: GetTableStateFn;
+    getColumnState: GetColumnStateFn;
+    setColumnState: SetColumneStateFn;
+    getSelectionState: GetSelectionStateFn;
+    setSelectionState: SetSelectionStateFn;
+    getSortState: GetSortStateStateFn;
+    setSortState: SetSortStateFn;
+};
+export default StateStorage;

package/dist/NewTable/StateStorage.js

@@ -0,0 +1,72 @@
+const get = (key, type) => {
+    const data = localStorage.getItem(key) || "";
+    if (type === "string") {
+        return data;
+    }
+    else {
+        try {
+            return JSON.parse(data);
+        }
+        catch (e) {
+            return {};
+        }
+    }
+};
+const set = (key, value) => {
+    if (typeof value === "object") {
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    else {
+        localStorage.setItem(key, value);
+    }
+};
+const del = (key) => {
+    localStorage.removeItem(key);
+};
+const getTableState = (key) => {
+    const data = get(key, "json");
+    return data;
+};
+const getColumnState = (key) => {
+    const data = getTableState(key);
+    return data.columnState;
+};
+const setColumnState = (key, value) => {
+    // get previous state
+    const previousState = getTableState(key);
+    // merge previous state with new state
+    const newState = Object.assign(Object.assign({}, previousState), { columnState: value });
+    set(key, newState);
+};
+const getSelectionState = (key) => {
+    const data = getTableState(key);
+    return data.selectionState;
+};
+const setSelectionState = (key, value) => {
+    // get previous state
+    const previousState = getTableState(key);
+    // merge previous state with new state
+    const newState = Object.assign(Object.assign({}, previousState), { selectionState: value });
+    set(key, newState);
+};
+const getSortState = (key) => {
+    const data = getTableState(key);
+    return data.sortState;
+};
+const setSortState = (key, value) => {
+    // get previous state
+    const previousState = getTableState(key);
+    // merge previous state with new state
+    const newState = Object.assign(Object.assign({}, previousState), { sortState: value });
+    set(key, newState);
+};
+const StateStorage = {
+    getTableState,
+    getColumnState,
+    setColumnState,
+    getSelectionState,
+    setSelectionState,
+    getSortState,
+    setSortState,
+};
+export default StateStorage;

package/dist/NewTable/StaticRows.d.ts

@@ -0,0 +1,5 @@
+declare const StaticRows: React.FC<{
+    targetElm: React.RefObject<HTMLDivElement>;
+    listElm: React.RefObject<HTMLDivElement>;
+}>;
+export default StaticRows;

package/dist/NewTable/StaticRows.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { TableListElement, TableViewPort, TBody } from "./TableComponents";
+import TableRow from "./TableRow";
+import useTable from "./useTable";
+const StaticRows = ({ targetElm, listElm }) => {
+    var _a;
+    const { data } = useTable();
+    return (_jsx(TBody, { className: "mfui-tbody", children: _jsx(TableViewPort, { className: "mfui-tbody-viewport", ref: targetElm, children: _jsx(TableListElement, { className: "mfui-tbody-list", ref: listElm, children: (_a = data === null || data === void 0 ? void 0 : data.map) === null || _a === void 0 ? void 0 : _a.call(data, (row, index) => (_jsx(TableRow, { rowData: row }, index))) }) }) }));
+};
+export default StaticRows;

package/dist/NewTable/Table.d.ts

@@ -0,0 +1,3 @@
+import { TableProps } from "./types";
+declare const Table: React.FC<TableProps>;
+export default Table;

package/dist/NewTable/Table.js

@@ -0,0 +1,83 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import Column from "./Column";
+import { useOverlayScrollbars } from "overlayscrollbars-react";
+import { StyledTable } from "./TableComponents";
+import TableHeader from "./TableHeader";
+import TableProvider from "./TableProvider";
+import shortUUID from "short-uuid";
+import VirtualizedRows from "./VirtualIzedRows";
+import StaticRows from "./StaticRows";
+const Table = (_a) => {
+    var { data, children } = _a, props = __rest(_a, ["data", "children"]) // pass through props straight to table context
+    ;
+    const tableElement = useRef(null);
+    const targetElm = useRef(null);
+    const listElm = useRef(null);
+    const headerRowElm = useRef(null);
+    // check if children is array and convert if not
+    if (!Array.isArray(children)) {
+        children = [children];
+    }
+    const [tableDimensions, setTableDimensions] = useState({
+        width: 0,
+        height: 0,
+    });
+    const handleOnScroll = (event) => {
+        // move header row horizontally with the scroll
+        const headerRow = headerRowElm.current;
+        if (headerRow) {
+            // shift position of header row
+            headerRow.style.transform = `translateX(-${event.target.scrollLeft}px)`; // move header row horizontally with the scroll
+        }
+    };
+    const [initialize, getInstance] = useOverlayScrollbars({
+        options: {
+            scrollbars: {
+                autoHide: "scroll",
+                autoHideDelay: 500,
+            },
+        },
+        events: { scroll: (_, event) => handleOnScroll(event) },
+    });
+    const getTableDimensions = () => {
+        if (tableElement.current) {
+            const { width, height } = tableElement.current.getBoundingClientRect();
+            setTableDimensions({ width, height });
+        }
+    };
+    useEffect(() => {
+        if (targetElm.current && listElm.current) {
+            initialize({
+                target: targetElm.current,
+                elements: {
+                    viewport: listElm.current,
+                },
+            });
+            return () => { var _a; return (_a = getInstance()) === null || _a === void 0 ? void 0 : _a.destroy(); };
+        }
+    }, [targetElm, listElm, initialize, getInstance]);
+    useLayoutEffect(() => {
+        getTableDimensions();
+        window.addEventListener("resize", getTableDimensions);
+        return () => {
+            window.removeEventListener("resize", getTableDimensions);
+        };
+    }, []);
+    const __data = useMemo(() => data === null || data === void 0 ? void 0 : data.map((d, i) => (Object.assign(Object.assign({}, d), { __key: shortUUID.generate(), __index: i }))), [data]);
+    return (_jsx(TableProvider, Object.assign({ columns: children
+            .filter((child) => child.type === Column)
+            .map((child) => child.props), data: __data }, props, { children: _jsxs(StyledTable, { className: "mfui-table", ref: tableElement, children: [_jsx(TableHeader, { headerRowElm: headerRowElm }), props.virtualized === true ? (_jsx(VirtualizedRows, { tableDimensions: tableDimensions, targetElm: targetElm, listElm: listElm, rowHeight: props.rowHeight, headerRowHeight: props.headerRowHeight, compact: props.compact })) : (_jsx(StaticRows, { targetElm: targetElm, listElm: listElm }))] }) })));
+};
+export default Table;

package/dist/NewTable/TableComponents.d.ts

@@ -0,0 +1,16 @@
+import { TDProps, TRProps } from "./types";
+export declare const THead: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TBody: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TR: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, TRProps>> & string;
+export declare const THR: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof TRProps> & TRProps, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, never>> & string;
+export declare const TD: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, TDProps>> & string;
+export declare const TH: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof TDProps> & TDProps, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, never>> & string;
+export declare const InnerCellContent: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TableViewPort: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TableListElement: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TableWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const StyledTable: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/NewTable/TableComponents.js

@@ -0,0 +1,139 @@
+import styled from "styled-components";
+import TableDefaults from "./TableDefaults";
+export const THead = styled.div ``;
+export const TBody = styled.div `
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  overflow: hidden;
+`;
+export const TR = styled.div `
+  display: flex;
+  flex-direction: row;
+
+  flex: 1;
+
+  height: ${({ compact, height }) => {
+    const customHeight = height ? height + "px" : undefined;
+    return compact
+        ? `${TableDefaults.row.height.compact}px`
+        : customHeight || `${TableDefaults.row.height.normal}px`;
+}};
+
+  border-left: 1px solid ${({ theme }) => theme.palette.divider};
+  border-right: 1px solid ${({ theme }) => theme.palette.divider};
+
+  // Get last row element and remove border bottom
+  // This is to prevent double border bottom on last row
+  //   &.mfui-tr:last-child .mfui-td {
+  //     border-bottom: none;
+  //   }
+
+  &:hover > .mfui-td {
+    background-color: ${({ theme }) => theme.palette.action.hover};
+  }
+`;
+export const THR = styled(TR) `
+  height: ${({ compact, height }) => {
+    const customHeight = height ? height + "px" : undefined;
+    return compact
+        ? `${TableDefaults.row.height.compact}px`
+        : customHeight || `${TableDefaults.row.height.normal}px`;
+}};
+
+  &:hover {
+    background-color: transparent;
+  }
+`;
+export const TD = styled.div `
+  position: relative;
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  flex: 1;
+
+  padding: ${({ compact }) => compact
+    ? `${TableDefaults.td.padding.compact}px`
+    : `${TableDefaults.td.padding.normal}px`};
+  font-size: ${({ compact }) => compact
+    ? `${TableDefaults.td.fontSize.compact}px`
+    : `${TableDefaults.td.fontSize.normal}px`};
+
+  min-width: ${TableDefaults.td.minWidth}px;
+
+  &:last-child {
+    flex: 1 !important; // ensure last column takes up remaining space
+  }
+
+  background-color: ${({ theme }) => theme.palette.background.default};
+
+  border-bottom: 1px solid ${({ theme }) => theme.palette.divider};
+`;
+export const TH = styled(TD) `
+  user-select: none;
+  text-align: left;
+  font-weight: bold;
+
+  background-color: ${({ theme }) => theme.palette.background.alt};
+
+  border-top: 1px solid ${({ theme }) => theme.palette.divider};
+  border-bottom: 1px solid ${({ theme }) => theme.palette.divider};
+
+  .inner-cell-content {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 5px;
+  }
+
+  &.dragover {
+    background-color: ${({ theme }) => theme.palette.primary.main}50;
+  }
+
+  // disable pointer events on children when dragging
+  &.dragover > * {
+    pointer-events: none;
+  }
+
+  &:hover {
+    background-color: ${({ theme }) => theme.palette.action.hover};
+  }
+`;
+export const InnerCellContent = styled.div `
+  max-width: 100%;
+
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+`;
+export const TableViewPort = styled.div `
+  display: flex;
+  flex-direction: column;
+`;
+export const TableListElement = styled.div `
+  display: flex;
+  flex-direction: column;
+`;
+export const TableWrapper = styled.div `
+  position: relative;
+  flex: 1 1 auto;
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+`;
+export const StyledTable = styled.div `
+  position: relative;
+  flex: 1 1 auto;
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+
+  //   border-left: 1px solid ${({ theme }) => theme.palette.divider};
+  //   border-right: 1px solid ${({ theme }) => theme.palette.divider};
+  //   border-bottom: 1px solid ${({ theme }) => theme.palette.divider};
+
+  .os-scrollbar {
+    pointer-events: auto;
+    visibility: visible;
+  }
+`;

package/dist/NewTable/TableDefaults.d.ts

@@ -0,0 +1,20 @@
+declare const TableDefaults: {
+    row: {
+        height: {
+            compact: number;
+            normal: number;
+        };
+    };
+    td: {
+        minWidth: number;
+        padding: {
+            compact: number;
+            normal: number;
+        };
+        fontSize: {
+            compact: number;
+            normal: number;
+        };
+    };
+};
+export default TableDefaults;

package/dist/NewTable/TableDefaults.js

@@ -0,0 +1,20 @@
+const TableDefaults = {
+    row: {
+        height: {
+            compact: 28,
+            normal: 38,
+        },
+    },
+    td: {
+        minWidth: 100,
+        padding: {
+            compact: 3,
+            normal: 8,
+        },
+        fontSize: {
+            compact: 10,
+            normal: 12,
+        },
+    },
+};
+export default TableDefaults;

package/dist/NewTable/TableHeader.d.ts

@@ -0,0 +1,3 @@
+import { TableHeaderProps } from "./types";
+declare const TableHeader: React.FC<TableHeaderProps>;
+export default TableHeader;