@synerise/ds-table-new 0.1.0

package/dist/hooks/useDefaultTexts.js

@@ -0,0 +1,95 @@
+import { useMemo } from "react";
+import { useIntl } from "react-intl";
+const useDefaultTexts = (defaultTexts) => {
+  const intl = useIntl();
+  return useMemo(() => ({
+    infiniteScrollLoading: intl.formatMessage({
+      id: "DS.TABLE.INFINITE-SCROLL-LOADING",
+      defaultMessage: "Loading"
+    }),
+    infiniteScrollError: intl.formatMessage({
+      id: "DS.TABLE.INFINITE-SCROLL-ERROR",
+      defaultMessage: "An error occurred"
+    }),
+    infiniteScrollRetry: intl.formatMessage({
+      id: "DS.TABLE.INFINITE-SCROLL-RETRY",
+      defaultMessage: "Retry"
+    }),
+    infiniteScrollNoMoreData: intl.formatMessage({
+      id: "DS.TABLE.INFINITE-SCROLL-NO-MORE-DATA",
+      defaultMessage: "There are no more items to load"
+    }),
+    columnSortClear: intl.formatMessage({
+      id: "DS.TABLE.COLUMN.SORT_CLEAR",
+      defaultMessage: "Clear"
+    }),
+    columnSortAscend: intl.formatMessage({
+      id: "DS.TABLE.COLUMN.SORT_ASCEND",
+      defaultMessage: "Sort ascending"
+    }),
+    columnSortDescend: intl.formatMessage({
+      id: "DS.TABLE.COLUMN.SORT_DESCEND",
+      defaultMessage: "Sort descending"
+    }),
+    columnSortZa: intl.formatMessage({
+      id: "DS.TABLE.COLUMN.SORT_ZA",
+      defaultMessage: "Sort z-a"
+    }),
+    columnSortAz: intl.formatMessage({
+      id: "DS.TABLE.COLUMN.SORT_AZ",
+      defaultMessage: "Sort a-z"
+    }),
+    totalItems: intl.formatMessage({
+      id: "DS.TABLE.ITEMS",
+      defaultMessage: "Records"
+    }),
+    selected: intl.formatMessage({
+      id: "DS.TABLE.SELECTED",
+      defaultMessage: "selected"
+    }),
+    selectAll: intl.formatMessage({
+      id: "DS.TABLE.SELECT-ALL",
+      defaultMessage: "Select visible"
+    }),
+    selectAllTooltip: intl.formatMessage({
+      id: "DS.TABLE.SELECT-ALL-TOOLTIP",
+      defaultMessage: "Select all"
+    }),
+    selectGlobalAll: intl.formatMessage({
+      id: "DS.TABLE.SELECT-GLOBAL-ALL",
+      defaultMessage: "Select all"
+    }),
+    selectInvert: intl.formatMessage({
+      id: "DS.TABLE.SELECT-INVERT",
+      defaultMessage: "Inverse selection"
+    }),
+    selectionLimitWarning: intl.formatMessage({
+      id: "DS.TABLE.SELECTION-LIMIT",
+      defaultMessage: "You have reached max limit"
+    }),
+    selectionOptionsTooltip: intl.formatMessage({
+      id: "DS.TABLE.SELECTIONS-MENU-TOOLTIP",
+      defaultMessage: "Batch selection options"
+    }),
+    unselectAll: intl.formatMessage({
+      id: "DS.TABLE.UNSELECT-ALL",
+      defaultMessage: "Unselect visible"
+    }),
+    unselectGlobalAll: intl.formatMessage({
+      id: "DS.TABLE.UNSELECT-GLOBAL-ALL",
+      defaultMessage: "Unselect all"
+    }),
+    emptyText: intl.formatMessage({
+      id: "DS.TABLE.NO-DATA",
+      defaultMessage: "No data"
+    }),
+    selectRowTooltip: intl.formatMessage({
+      id: "DS.TABLE.SELECT-ROW",
+      defaultMessage: "Select"
+    }),
+    ...defaultTexts
+  }), [intl, defaultTexts]);
+};
+export {
+  useDefaultTexts
+};

package/dist/hooks/useInfiniteScroll.d.ts

@@ -0,0 +1,13 @@
+import { Dispatch, SetStateAction } from 'react';
+import { Virtualizer } from '@tanstack/react-virtual';
+import { InfiniteScrollProps, OnItemsRenderedProps, StickyData } from '../Table.types';
+type UseInfiniteScrollProps = {
+    infiniteScroll?: InfiniteScrollProps;
+    onItemsRendered?: (props: OnItemsRenderedProps) => void;
+    setStickyData?: Dispatch<SetStateAction<StickyData>>;
+};
+export declare const useInfiniteScroll: ({ infiniteScroll, onItemsRendered, setStickyData, }: UseInfiniteScrollProps) => {
+    scrollDirection: "forward" | "backward" | null;
+    handleScrollDirection: (virtualiser: Virtualizer<HTMLDivElement, Element>, isScrolling: boolean) => void;
+};
+export {};

package/dist/hooks/useInfiniteScroll.js

@@ -0,0 +1,58 @@
+import { useState, useCallback, useEffect } from "react";
+import { INFINITE_SCROLL_TRIGGER_THRESHOLD, INFINITE_SCROLL_PADDING_START } from "../Table.const.js";
+const useInfiniteScroll = ({
+  infiniteScroll,
+  onItemsRendered,
+  setStickyData
+}) => {
+  const [scrollDirection, setScrollDirection] = useState(null);
+  const [isCurrentlyScrolling, setIsCurrentlyScrolling] = useState(false);
+  const handleInfiniteScroll = useCallback((containerRefElement, dir) => {
+    if (containerRefElement) {
+      const {
+        scrollHeight,
+        scrollTop,
+        clientHeight
+      } = containerRefElement;
+      if (scrollHeight - scrollTop - clientHeight < INFINITE_SCROLL_TRIGGER_THRESHOLD && infiniteScroll?.nextPage?.hasMore && !infiniteScroll?.nextPage?.isLoading && dir === "forward") {
+        infiniteScroll?.onScrollEndReach?.();
+      } else if (scrollTop < INFINITE_SCROLL_TRIGGER_THRESHOLD && infiniteScroll?.prevPage?.hasMore && !infiniteScroll?.prevPage?.isLoading && dir === "backward") {
+        infiniteScroll?.onScrollTopReach?.();
+      }
+    }
+  }, [infiniteScroll]);
+  const handleScrollDirection = useCallback((virtualiser, isScrolling) => {
+    const itemAtOffset = virtualiser.getVirtualItemForOffset((virtualiser.scrollOffset || 0) - INFINITE_SCROLL_PADDING_START);
+    const firstVisibleItem = itemAtOffset?.size === 0 ? virtualiser.getVirtualItems().find((v) => v.index > itemAtOffset.index && v.size > 0) : itemAtOffset;
+    if (firstVisibleItem !== void 0) {
+      onItemsRendered?.({
+        visibleStartIndex: firstVisibleItem.index
+      });
+    }
+    setIsCurrentlyScrolling(isScrolling);
+    if (infiniteScroll && isScrolling) {
+      handleInfiniteScroll(virtualiser.scrollElement, virtualiser.scrollDirection);
+    }
+    if (virtualiser.scrollDirection) {
+      setScrollDirection(virtualiser.scrollDirection);
+    }
+    if (!virtualiser.scrollOffset) {
+      setScrollDirection(null);
+    }
+  }, [handleInfiniteScroll, infiniteScroll, onItemsRendered]);
+  useEffect(() => {
+    if (isCurrentlyScrolling && scrollDirection === "forward") {
+      setStickyData?.((prev) => ({
+        ...prev,
+        isRevealed: false
+      }));
+    }
+  }, [isCurrentlyScrolling, scrollDirection, setStickyData]);
+  return {
+    scrollDirection,
+    handleScrollDirection
+  };
+};
+export {
+  useInfiniteScroll
+};

package/dist/hooks/useRowKey.d.ts

@@ -0,0 +1,4 @@
+import { Row, RowData } from '@tanstack/react-table';
+export declare const useRowKey: <TData extends RowData>(rowKey: keyof TData | ((row: TData) => string) | undefined) => {
+    getRowKey: (row: TData, index: number, parent?: Row<TData>) => string;
+};

package/dist/hooks/useRowKey.js

@@ -0,0 +1,27 @@
+import { useCallback } from "react";
+const parentIndex = (row) => {
+  const parent = row.getParentRow();
+  return `.${row.index}${parent ? parentIndex(parent) : ""}`;
+};
+const generateIdFromIndex = (index, parent) => {
+  return `${index}${parent ? parentIndex(parent) : ""}`;
+};
+const useRowKey = (rowKey) => {
+  const getRowKey = useCallback((row, index, parent) => {
+    if (typeof rowKey === "function") {
+      return rowKey(row);
+    }
+    if (typeof rowKey === "string") {
+      return String(row[rowKey]);
+    }
+    const record = row;
+    const fallback = record.key || record.id;
+    return fallback ? String(fallback) : generateIdFromIndex(index, parent);
+  }, [rowKey]);
+  return {
+    getRowKey
+  };
+};
+export {
+  useRowKey
+};

package/dist/hooks/useScrollSync.d.ts

@@ -0,0 +1,2 @@
+import { MutableRefObject } from 'react';
+export declare const useScrollSync: (refs: MutableRefObject<HTMLElement[]>) => void;

package/dist/hooks/useScrollSync.js

@@ -0,0 +1,23 @@
+import { useEffect } from "react";
+const useScrollSync = (refs) => {
+  useEffect(() => {
+    const nodes = refs.current;
+    if (!nodes.length) {
+      return;
+    }
+    const scrollHandler = (event) => {
+      nodes.forEach((elem) => {
+        if (elem !== event.currentTarget) {
+          elem.scrollLeft = event.currentTarget?.scrollLeft;
+        }
+      });
+    };
+    nodes.forEach((elem) => elem.addEventListener("scroll", scrollHandler));
+    return () => {
+      nodes.forEach((elem) => elem.removeEventListener("scroll", scrollHandler));
+    };
+  });
+};
+export {
+  useScrollSync
+};

package/dist/hooks/useTable.d.ts

@@ -0,0 +1,14 @@
+import { MutableRefObject } from 'react';
+import { SharedTableProps, TableProps, VirtualTableProps } from '../Table.types';
+type UseTableProps<TData, TValue> = Pick<VirtualTableProps<TData, TValue>, 'infiniteScroll'> & Pick<TableProps<TData, TValue>, 'pagination'> & Pick<SharedTableProps<TData, TValue>, 'data' | 'selectionConfig' | 'columns' | 'rowKey' | 'onSort' | 'expandable' | 'selectedRowKeys'> & {
+    wrapperRef: MutableRefObject<HTMLDivElement | null>;
+    requireColumnSizing?: boolean;
+};
+export declare const useTable: <TData, TValue>({ data, selectionConfig, columns, rowKey, wrapperRef, infiniteScroll, pagination, onSort, expandable, selectedRowKeys, requireColumnSizing, }: UseTableProps<TData, TValue>) => {
+    table: import('@tanstack/react-table').Table<TData>;
+    paginationProps: {} | {};
+    hasPagination: boolean;
+    columnSizing: import('@tanstack/react-table').ColumnSizingState;
+    isColumnSizingReady: boolean;
+};
+export {};

package/dist/hooks/useTable.js

@@ -0,0 +1,168 @@
+import { useState, useEffect, useRef, useLayoutEffect, useCallback, useMemo } from "react";
+import { useReactTable, getGroupedRowModel, getExpandedRowModel, getPaginationRowModel, getSortedRowModel, getCoreRowModel } from "@tanstack/react-table";
+import { EMPTY_SORT_STATE } from "../Table.const.js";
+import { arrayToTrueMap } from "../utils/arrayToTrueMap.js";
+import { compareKeys } from "../utils/compareKeys.js";
+import { getChildrenColumnName } from "../utils/getChildrenColumnName.js";
+import { getPaginationConfig } from "../utils/getPaginationConfig.js";
+import { useColumnSizing } from "./useColumnSizing.js";
+import { useRowKey } from "./useRowKey.js";
+const useTable = ({
+  data,
+  selectionConfig,
+  columns,
+  rowKey,
+  wrapperRef,
+  infiniteScroll,
+  pagination,
+  onSort,
+  expandable,
+  selectedRowKeys,
+  requireColumnSizing = true
+}) => {
+  const [rowSelection, setRowSelection] = useState({});
+  const [sorting, setSorting] = useState([]);
+  const childrenColumnName = getChildrenColumnName(expandable?.childrenColumnName);
+  useEffect(() => {
+    const localSelectionKeys = Object.keys(rowSelection);
+    if (selectedRowKeys && !compareKeys(selectedRowKeys, localSelectionKeys)) {
+      setRowSelection(arrayToTrueMap(selectedRowKeys));
+    }
+  }, [selectedRowKeys]);
+  const dataRef = useRef(data);
+  useLayoutEffect(() => {
+    dataRef.current = data;
+  }, [data]);
+  const {
+    getRowKey
+  } = useRowKey(rowKey);
+  const memoizedGetRowKey = useCallback((row, index) => getRowKey(row, index), [getRowKey]);
+  const handleSortingChange = useCallback((updaterOrValue) => {
+    setSorting((oldSorting) => {
+      const newSorting = typeof updaterOrValue === "function" ? updaterOrValue(oldSorting) : updaterOrValue;
+      if (onSort) {
+        if (newSorting.length) {
+          const singleColumnSort = newSorting[0];
+          const sortState = {};
+          newSorting.forEach((column, index) => {
+            sortState[column.id] = {
+              sortOrder: column.desc ? "descend" : "ascend",
+              multiple: index
+            };
+          });
+          onSort({
+            columnKey: singleColumnSort.id,
+            order: singleColumnSort.desc ? "descend" : "ascend"
+          }, sortState);
+        } else {
+          onSort(...EMPTY_SORT_STATE);
+        }
+      }
+      return newSorting;
+    });
+  }, [onSort]);
+  const handleSelectionChange = useCallback((updaterOrValue) => {
+    setRowSelection((oldSelection) => {
+      const newSelection = typeof updaterOrValue === "function" ? updaterOrValue(oldSelection) : updaterOrValue;
+      if (selectionConfig?.onChange) {
+        const ids = Object.keys(newSelection);
+        const items = dataRef.current.filter((item, index) => ids.includes(memoizedGetRowKey(item, index)));
+        selectionConfig?.onChange(ids, items);
+      }
+      return newSelection;
+    });
+  }, [selectionConfig, memoizedGetRowKey]);
+  const columnWidths = useMemo(() => columns.map((column) => ({
+    id: column.id,
+    minWidth: column.minSize ?? (column.meta?.minWidth ? parseInt(`${column.meta?.minWidth}`) : void 0),
+    width: column.size ?? (column.meta?.width ? parseInt(`${column.meta?.width}`) : void 0),
+    maxWidth: column.maxSize ?? (column.meta?.maxWidth ? parseInt(`${column.meta?.maxWidth}`) : void 0)
+  })), [columns]);
+  const hasAnyColumnWidth = columnWidths.some((col) => col.width !== void 0 || col.minWidth !== void 0 || col.maxWidth !== void 0);
+  const {
+    columnSizing,
+    isColumnSizingReady
+  } = useColumnSizing({
+    columnWidths,
+    wrapperRef,
+    enabled: requireColumnSizing || hasAnyColumnWidth
+  });
+  const {
+    rightPinnedColumns,
+    leftPinnedColumns
+  } = useMemo(() => {
+    const right = [];
+    const left = [];
+    columns.forEach((column) => {
+      if (column.meta?.fixed === "right") {
+        right.push(column.id);
+      }
+      if (column.meta?.fixed === "left") {
+        left.push(column.id);
+      }
+    });
+    return {
+      rightPinnedColumns: right,
+      leftPinnedColumns: left
+    };
+  }, [columns]);
+  const hasPagination = !infiniteScroll && pagination !== false;
+  const {
+    initialState: paginationInitialState,
+    ...paginationProps
+  } = getPaginationConfig(!infiniteScroll && pagination);
+  const getSubRows = useCallback((row) => {
+    return row[childrenColumnName];
+  }, [childrenColumnName]);
+  const expandedKeys = expandable?.expandedRowKeys ? arrayToTrueMap(expandable?.expandedRowKeys) : void 0;
+  const table = useReactTable({
+    getRowId: memoizedGetRowKey,
+    data,
+    columns,
+    getSubRows: childrenColumnName ? getSubRows : void 0,
+    getCoreRowModel: getCoreRowModel(),
+    getSortedRowModel: getSortedRowModel(),
+    getPaginationRowModel: hasPagination ? getPaginationRowModel() : void 0,
+    getExpandedRowModel: expandable ? getExpandedRowModel() : void 0,
+    getGroupedRowModel: getGroupedRowModel(),
+    onRowSelectionChange: handleSelectionChange,
+    onExpandedChange: () => {
+    },
+    onSortingChange: handleSortingChange,
+    enableRowSelection: (row) => {
+      const {
+        unavailable,
+        disabled
+      } = selectionConfig?.checkRowSelectionStatus?.(row.original) || {};
+      return !!selectionConfig && !unavailable && !disabled;
+    },
+    manualExpanding: !!expandable?.expandedRowKeys,
+    initialState: {
+      columnPinning: {
+        right: rightPinnedColumns,
+        left: leftPinnedColumns
+      },
+      ...paginationInitialState,
+      expanded: expandedKeys
+    },
+    state: {
+      columnPinning: {
+        right: rightPinnedColumns,
+        left: leftPinnedColumns
+      },
+      sorting,
+      rowSelection,
+      expanded: expandedKeys
+    }
+  });
+  return {
+    table,
+    paginationProps,
+    hasPagination,
+    columnSizing,
+    isColumnSizingReady
+  };
+};
+export {
+  useTable
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Table } from './Table';
+export { VirtualTable } from './VirtualTable';
+/** @deprecated  */
+export * as TableCell from './components/Cell';
+export * from './components/Cell';
+export * from './Table.types';
+export * from './Table.const';
+export { legacyColumnConfigAdapter } from './utils/legacyColumnConfigAdapter';
+export { type ColumnDef, type Row, type CellContext, type HeaderContext, } from '@tanstack/react-table';

package/dist/index.js

@@ -0,0 +1,50 @@
+import { Table } from "./Table.js";
+import { VirtualTable } from "./VirtualTable.js";
+import * as components_Cell_index from "./components/Cell/index.js";
+import { ACTION_COLUMN_ID, BOTTOM_BORDER_WIDTH, DEFAULT_CELL_HEIGHT, DEFAULT_PAGINATION_CONFIG, DEFAULT_STICKY_VALUE, EMPTY_SORT_STATE, EXPANDED_ROW_PROPERTY, INFINITE_LOADER_ITEM_HEIGHT, INFINITE_SCROLL_PADDING_START, INFINITE_SCROLL_TRIGGER_THRESHOLD, SELECTION_ALL, SELECTION_COLUMN_ID, SELECTION_INVERT } from "./Table.const.js";
+import { legacyColumnConfigAdapter } from "./utils/legacyColumnConfigAdapter.js";
+import { ActionCell } from "./components/Cell/Action/ActionCell.js";
+import { AvatarLabelCell } from "./components/Cell/AvatarLabel/AvatarLabel.js";
+import { CopyableCell } from "./components/Cell/Copyable/CopyableCell.js";
+import { EditableCell } from "./components/Cell/Editable/EditableCell.js";
+import { FlagLabelCell } from "./components/Cell/FlagLabel/FlagLabelCell.js";
+import { IconLabelCell } from "./components/Cell/IconLabel/IconLabel.js";
+import { IconTooltipCell } from "./components/Cell/IconTooltipCell/IconTooltipCell.js";
+import { InputNumberCell } from "./components/Cell/InputNumber/InputNumberCell.js";
+import { LabelsWithShowMore } from "./components/Cell/LabelsWithShowMore/LabelsWithShowMore.js";
+import { StarCell } from "./components/Cell/Star/StarCell.js";
+import { StatusLabelCell } from "./components/Cell/StatusLabel/StatusLabel.js";
+import { TagIconCell } from "./components/Cell/TagIcon/TagIcon.js";
+import { TagsGroupCell } from "./components/Cell/TagsGroup/TagsGroup.js";
+export {
+  ACTION_COLUMN_ID,
+  ActionCell,
+  AvatarLabelCell,
+  BOTTOM_BORDER_WIDTH,
+  CopyableCell,
+  DEFAULT_CELL_HEIGHT,
+  DEFAULT_PAGINATION_CONFIG,
+  DEFAULT_STICKY_VALUE,
+  EMPTY_SORT_STATE,
+  EXPANDED_ROW_PROPERTY,
+  EditableCell,
+  FlagLabelCell,
+  INFINITE_LOADER_ITEM_HEIGHT,
+  INFINITE_SCROLL_PADDING_START,
+  INFINITE_SCROLL_TRIGGER_THRESHOLD,
+  IconLabelCell,
+  IconTooltipCell,
+  InputNumberCell,
+  LabelsWithShowMore,
+  SELECTION_ALL,
+  SELECTION_COLUMN_ID,
+  SELECTION_INVERT,
+  StarCell,
+  StatusLabelCell,
+  Table,
+  components_Cell_index as TableCell,
+  TagIconCell,
+  TagsGroupCell,
+  VirtualTable,
+  legacyColumnConfigAdapter
+};

package/dist/types/table.d.js

@@ -0,0 +1 @@
+

package/dist/types/table.d.ts

@@ -0,0 +1,28 @@
+import { CellContext, HeaderContext, RowData, ColumnDefTemplate } from '@tanstack/react-table';
+import { TooltipProps } from '@synerise/ds-tooltip';
+import { CSSProperties, ReactNode } from 'react';
+declare module '@tanstack/react-table' {
+  interface ColumnMeta<TData extends RowData, TValue> {
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    width?: number | string;
+    fixed?: 'left' | 'right';
+    style?: CSSProperties<HTMLTableHeaderCellElement>;
+    sortRender?: 'string' | 'default';
+    sortOrder?: 'ascend' | 'descend' | null;
+    renderCustomSortButton?: (
+      headerContext: HeaderContext<TData, TValue>,
+    ) => ReactNode;
+    childCell?: ColumnDefTemplate<CellContext<TData, TValue>>;
+    skeletonCell?: () => ReactNode;
+    dataIndex?: string;
+    title?: string;
+    enableMultiSort?: boolean;
+    /**
+     * Returns tooltip props for cells in this column, or false to disable tooltip.
+     * When provided, the cell content is wrapped in a Tooltip component.
+     */
+    getCellTooltipProps?: (row: TData) => TooltipProps | false;
+  }
+}
+

package/dist/utils/arrayToTrueMap.d.ts

@@ -0,0 +1 @@
+export declare const arrayToTrueMap: <T extends string | number | symbol>(items: readonly T[]) => Record<T, true>;

package/dist/utils/arrayToTrueMap.js

@@ -0,0 +1,7 @@
+const arrayToTrueMap = (items) => items.reduce((acc, item) => {
+  acc[item] = true;
+  return acc;
+}, {});
+export {
+  arrayToTrueMap
+};

package/dist/utils/calculatePixels.d.ts

@@ -0,0 +1 @@
+export declare const calculatePixels: (value: number | string | undefined) => number | undefined;

package/dist/utils/calculatePixels.js

@@ -0,0 +1,21 @@
+import toPx from "unit-to-px";
+const hasSameLength = (parsedValue, originalValue) => `${parsedValue}`.length === `${originalValue}`.length;
+const calculatePixels = (value) => {
+  if (typeof value === "number") {
+    return value;
+  }
+  const isWhiteSpaceString = typeof value === "string" && !value.trim();
+  if (!value || isWhiteSpaceString) {
+    return 0;
+  }
+  if (typeof value !== "number" && !Number.isNaN(value) && !Number.isNaN(parseFloat(value))) {
+    const parsedNumber = parseFloat(value);
+    if (hasSameLength(parsedNumber, value)) {
+      return parsedNumber;
+    }
+  }
+  return toPx(value);
+};
+export {
+  calculatePixels
+};

package/dist/utils/compareKeys.d.ts

@@ -0,0 +1 @@
+export declare const compareKeys: (a: string[], b: string[]) => boolean;

package/dist/utils/compareKeys.js

@@ -0,0 +1,16 @@
+const compareKeys = (a, b) => {
+  const sa = new Set(a);
+  const sb = new Set(b);
+  if (sa.size !== sb.size) {
+    return false;
+  }
+  for (const v of sa) {
+    if (!sb.has(v)) {
+      return false;
+    }
+  }
+  return true;
+};
+export {
+  compareKeys
+};

package/dist/utils/getChildrenColumnName.d.ts

@@ -0,0 +1 @@
+export declare const getChildrenColumnName: <TData>(childrenColumnName?: keyof TData) => "children" | keyof TData;

package/dist/utils/getChildrenColumnName.js

@@ -0,0 +1,7 @@
+const DEFAULT_CHILDREN_COLUMN_NAME = "children";
+const getChildrenColumnName = (childrenColumnName) => {
+  return childrenColumnName || DEFAULT_CHILDREN_COLUMN_NAME;
+};
+export {
+  getChildrenColumnName
+};

package/dist/utils/getDefaultSkeletonColumns.d.ts

@@ -0,0 +1,2 @@
+import { ColumnDef } from '@tanstack/react-table';
+export declare const getDefaultSkeletonColumns: <TData, TValue>() => ColumnDef<TData, TValue>[];

package/dist/utils/getDefaultSkeletonColumns.js

@@ -0,0 +1,58 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import { SkeletonAvatar } from "@synerise/ds-skeleton";
+import { AvatarLabelCell } from "../components/Cell/AvatarLabel/AvatarLabel.js";
+import { TableSkeletonCell, Skeleton } from "../components/TableBody/TableBodySkeleton/TableBodySkeleton.styles.js";
+const getDefaultSkeletonColumns = () => {
+  const renderTitleSkeleton = (skeletonWidth) => /* @__PURE__ */ jsx(TableSkeletonCell, { children: /* @__PURE__ */ jsx(Skeleton, { skeletonWidth, numberOfSkeletons: 1, width: "M" }) });
+  const renderCellSkeleton = () => /* @__PURE__ */ jsx(TableSkeletonCell, { children: /* @__PURE__ */ jsx(Skeleton, { numberOfSkeletons: 1, size: "M" }) });
+  const renderAvatarCell = () => /* @__PURE__ */ jsx(TableSkeletonCell, { children: /* @__PURE__ */ jsx(AvatarLabelCell, { title: /* @__PURE__ */ jsx(Skeleton, { skeletonWidth: "120px", numberOfSkeletons: 1, width: "M" }), avatar: /* @__PURE__ */ jsx(SkeletonAvatar, { shape: "square", size: "M" }) }) });
+  const buildMeta = (skeletonCell, width, minWidth) => ({
+    ...minWidth !== void 0 ? {
+      minWidth
+    } : {},
+    ...width !== void 0 ? {
+      width
+    } : {},
+    childCell: () => null,
+    skeletonCell
+  });
+  const columns = [{
+    accessorKey: "undefined",
+    header: () => renderTitleSkeleton("140px"),
+    meta: buildMeta(renderAvatarCell, 350),
+    size: 350,
+    enableSorting: false,
+    id: "col-0"
+  }, {
+    accessorKey: "undefined",
+    header: () => "",
+    meta: buildMeta(() => /* @__PURE__ */ jsx(Fragment, {}), void 0, 100),
+    enableSorting: false,
+    id: "col-1"
+  }, {
+    accessorKey: "undefined",
+    header: () => renderTitleSkeleton(),
+    meta: buildMeta(renderCellSkeleton, 120),
+    size: 120,
+    enableSorting: false,
+    id: "col-2"
+  }, {
+    accessorKey: "undefined",
+    header: () => renderTitleSkeleton(),
+    meta: buildMeta(renderCellSkeleton, 212),
+    size: 212,
+    enableSorting: false,
+    id: "col-3"
+  }, {
+    accessorKey: "undefined",
+    header: () => renderTitleSkeleton(),
+    meta: buildMeta(renderCellSkeleton, 120),
+    size: 120,
+    enableSorting: false,
+    id: "col-4"
+  }];
+  return columns;
+};
+export {
+  getDefaultSkeletonColumns
+};

package/dist/utils/getInfiniteScrollPadding.d.ts

@@ -0,0 +1,2 @@
+import { InfiniteScrollProps } from '../Table.types';
+export declare const getInfiniteScrollPadding: (infiniteScroll?: InfiniteScrollProps) => number;

package/dist/utils/getInfiniteScrollPadding.js

@@ -0,0 +1,13 @@
+import { INFINITE_LOADER_ITEM_HEIGHT } from "../Table.const.js";
+const getInfiniteScrollPadding = (infiniteScroll) => {
+  if (!infiniteScroll) {
+    return 0;
+  }
+  if (infiniteScroll.prevPage?.hasMore) {
+    return 2 * INFINITE_LOADER_ITEM_HEIGHT;
+  }
+  return INFINITE_LOADER_ITEM_HEIGHT;
+};
+export {
+  getInfiniteScrollPadding
+};

package/dist/utils/getIsRevealed.d.ts

@@ -0,0 +1,5 @@
+import { ScrollDirection } from '../Table.types';
+export declare const getIsRevealed: ({ scrollDirection, hasData, }: {
+    hasData: boolean;
+    scrollDirection: ScrollDirection;
+}) => boolean;