@synerise/ds-table 1.9.11 → 1.9.12

package/dist/hooks/useBulkSelection/useBulkSelection.js

@@ -1,22 +1,30 @@
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-import { useCallback, useMemo } from 'react';
-import { isRecordSelectable } from '../../utils';
-import { useRowKey } from '../useRowKey';
-export var useBulkSelectionCount = function useBulkSelectionCount(_ref) {
-  var dataSource = _ref.dataSource,
-    selection = _ref.selection,
-    childrenColumnName = _ref.childrenColumnName,
-    rowKey = _ref.rowKey;
-  var _useRowKey = useRowKey(rowKey),
-    getRowKey = _useRowKey.getRowKey;
-  var getSelectableChildren = useCallback(function (children) {
-    var selectionStatusValidator = (selection == null ? void 0 : selection.checkRowSelectionStatus) || undefined;
-    return children ? children.filter(function (child) {
-      return isRecordSelectable(child, selectionStatusValidator) && getRowKey(child) !== undefined;
-    }) : [];
-  }, [getRowKey, selection == null ? void 0 : selection.checkRowSelectionStatus]);
-  var result = useMemo(function () {
-    var initialValue = {
+import { useCallback, useMemo } from "react";
+import "unit-to-px";
+import "react/jsx-runtime";
+import "../../Table.styles.js";
+import "@synerise/ds-skeleton";
+import "uuid";
+import "styled-components";
+import "@synerise/ds-typography";
+import "ramda";
+import { isRecordSelectable } from "../../utils/isRecordSelectable.js";
+import "../../utils/locale.js";
+import { useRowKey } from "../useRowKey/useRowKey.js";
+const useBulkSelectionCount = ({
+  dataSource,
+  selection,
+  childrenColumnName,
+  rowKey
+}) => {
+  const {
+    getRowKey
+  } = useRowKey(rowKey);
+  const getSelectableChildren = useCallback((children) => {
+    const selectionStatusValidator = selection?.checkRowSelectionStatus || void 0;
+    return children ? children.filter((child) => isRecordSelectable(child, selectionStatusValidator) && getRowKey(child) !== void 0) : [];
+  }, [getRowKey, selection?.checkRowSelectionStatus]);
+  const result = useMemo(() => {
+    const initialValue = {
       selectableRecordsCount: 0,
       selectableAndSelectedRecordsCount: 0,
       selectedRecordsCount: 0
@@ -24,44 +32,51 @@ export var useBulkSelectionCount = function useBulkSelectionCount(_ref) {
     if (!dataSource.length || !selection) {
       return initialValue;
     }
-    var selectedRowKeys = selection.selectedRowKeys,
-      independentSelectionExpandedRows = selection.independentSelectionExpandedRows,
-      checkRowSelectionStatus = selection.checkRowSelectionStatus;
-    return dataSource.reduce(function (count, record) {
-      var isSelectable = +isRecordSelectable(record, checkRowSelectionStatus);
-      var rowChildren = record[childrenColumnName];
-      var selectableRecordsCount = count.selectableRecordsCount,
-        selectableAndSelectedRecordsCount = count.selectableAndSelectedRecordsCount,
-        selectedRecordsCount = count.selectedRecordsCount;
-      // selectable
+    const {
+      selectedRowKeys,
+      independentSelectionExpandedRows,
+      checkRowSelectionStatus
+    } = selection;
+    return dataSource.reduce((count, record) => {
+      const isSelectable = +isRecordSelectable(record, checkRowSelectionStatus);
+      const rowChildren = record[childrenColumnName];
+      let {
+        selectableRecordsCount,
+        selectableAndSelectedRecordsCount,
+        selectedRecordsCount
+      } = count;
       if (independentSelectionExpandedRows) {
         Array.isArray(rowChildren) ? selectableRecordsCount += getSelectableChildren(rowChildren).length + isSelectable : selectableRecordsCount += isSelectable;
       } else {
         Array.isArray(rowChildren) ? selectableRecordsCount += getSelectableChildren(rowChildren).length : selectableRecordsCount += isSelectable;
       }
       if (Array.isArray(rowChildren)) {
-        selectedRecordsCount += rowChildren.reduce(function (childCount, child) {
-          var key = getRowKey(child);
+        selectedRecordsCount += rowChildren.reduce((childCount, child) => {
+          const key = getRowKey(child);
           return selectedRowKeys.includes(key) ? childCount + 1 : childCount;
         }, 0);
-        selectableAndSelectedRecordsCount += rowChildren.reduce(function (childCount, child) {
-          var key = getRowKey(child);
+        selectableAndSelectedRecordsCount += rowChildren.reduce((childCount, child) => {
+          const key = getRowKey(child);
           return selectedRowKeys.includes(key) && isRecordSelectable(child, checkRowSelectionStatus) ? childCount + 1 : childCount;
         }, 0);
       }
       if (!Array.isArray(rowChildren) || selection.independentSelectionExpandedRows) {
-        var key = getRowKey(record);
+        const key = getRowKey(record);
         selectedRecordsCount += selectedRowKeys.includes(key) ? 1 : 0;
         selectableAndSelectedRecordsCount += selectedRowKeys.includes(key) && isRecordSelectable(record, checkRowSelectionStatus) ? 1 : 0;
       }
       return {
-        selectableRecordsCount: selectableRecordsCount,
-        selectableAndSelectedRecordsCount: selectableAndSelectedRecordsCount,
-        selectedRecordsCount: selectedRecordsCount
+        selectableRecordsCount,
+        selectableAndSelectedRecordsCount,
+        selectedRecordsCount
       };
     }, initialValue);
   }, [childrenColumnName, dataSource, getRowKey, getSelectableChildren, selection]);
-  return _extends({}, result, {
+  return {
+    ...result,
     allRecordsCount: dataSource.length
-  });
-};
+  };
+};
+export {
+  useBulkSelectionCount
+};

package/dist/hooks/useRowKey/index.js

@@ -1 +1,4 @@
-export * from './useRowKey';
+import { useRowKey } from "./useRowKey.js";
+export {
+  useRowKey
+};

package/dist/hooks/useRowKey/useRowKey.js

@@ -1,18 +1,18 @@
-import React from 'react';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-export var useRowKey = function useRowKey(rowKey) {
-  var getRowKey = React.useCallback(function (row) {
-    if (typeof rowKey === 'function') {
+import React from "react";
+const useRowKey = (rowKey) => {
+  const getRowKey = React.useCallback((row) => {
+    if (typeof rowKey === "function") {
       return rowKey(row);
     }
-    if (typeof rowKey === 'string') {
+    if (typeof rowKey === "string") {
       return row[rowKey];
     }
-    return row.key || undefined;
+    return row.key || void 0;
   }, [rowKey]);
   return {
-    getRowKey: getRowKey
+    getRowKey
   };
-};
+};
+export {
+  useRowKey
+};

package/dist/hooks/useRowStar/index.js

@@ -1,2 +1,4 @@
-export * from './useRowStar.types';
-export * from './useRowStar';
+import { useRowStar } from "./useRowStar.js";
+export {
+  useRowStar
+};

package/dist/hooks/useRowStar/useRowStar.d.ts

@@ -1,2 +1,2 @@
-import { type UseStarredApi } from './useRowStar.types';
+import { UseStarredApi } from './useRowStar.types';
 export declare const useRowStar: (initialStarredKeys: string[]) => UseStarredApi;

package/dist/hooks/useRowStar/useRowStar.js

@@ -1,72 +1,64 @@
-import React from 'react';
-import Button from '@synerise/ds-button';
-import Tooltip from '@synerise/ds-tooltip';
-var STAR_COL_WIDTH_SINGLE = 64;
-var STAR_COL_WIDTH_SELECTON = 40;
-var createRowStarColumn = function createRowStarColumn(_ref) {
-  var isStarred = _ref.isStarred,
-    toggleStarred = _ref.toggleStarred;
-  return function (_ref2) {
-    var locale = _ref2.locale,
-      rowStar = _ref2.rowStar,
-      selection = _ref2.selection,
-      getRowKey = _ref2.getRowKey,
-      loading = _ref2.loading;
-    return {
-      key: '_row-star',
-      className: ((rowStar == null ? void 0 : rowStar.className) || '') + " ds-table-star-column",
-      width: !!selection && !!rowStar ? STAR_COL_WIDTH_SELECTON : STAR_COL_WIDTH_SINGLE,
-      render: (rowStar == null ? void 0 : rowStar.renderCell) || function (value, record) {
-        var expandedChild = record.expandedChild;
-        var keyString = String(getRowKey(record));
-        if (loading || expandedChild && rowStar != null && rowStar.disableForExpandedRows) {
-          return null;
-        }
-        return /*#__PURE__*/React.createElement(Tooltip, {
-          title: locale == null ? void 0 : locale.starRowTooltip
-        }, /*#__PURE__*/React.createElement(Button.Star, {
-          "data-testid": "ds-table-star-button",
-          active: isStarred(keyString),
-          onClick: function onClick(e) {
-            var newStarredRowKeys = toggleStarred(keyString);
-            if (typeof (rowStar == null ? void 0 : rowStar.onChange) === 'function') {
-              rowStar.onChange(newStarredRowKeys, keyString, isStarred(keyString));
-            }
-            if (typeof (rowStar == null ? void 0 : rowStar.onClick) === 'function') {
-              rowStar.onClick(e);
-            }
-          }
-        }));
+import { jsx } from "react/jsx-runtime";
+import React from "react";
+import Button from "@synerise/ds-button";
+import Tooltip from "@synerise/ds-tooltip";
+const STAR_COL_WIDTH_SINGLE = 64;
+const STAR_COL_WIDTH_SELECTON = 40;
+const createRowStarColumn = ({
+  isStarred,
+  toggleStarred
+}) => ({
+  locale,
+  rowStar,
+  selection,
+  getRowKey,
+  loading
+}) => ({
+  key: "_row-star",
+  className: `${rowStar?.className || ""} ds-table-star-column`,
+  width: !!selection && !!rowStar ? STAR_COL_WIDTH_SELECTON : STAR_COL_WIDTH_SINGLE,
+  render: rowStar?.renderCell || ((value, record) => {
+    const {
+      expandedChild
+    } = record;
+    const keyString = String(getRowKey(record));
+    if (loading || expandedChild && rowStar?.disableForExpandedRows) {
+      return null;
+    }
+    return /* @__PURE__ */ jsx(Tooltip, { title: locale?.starRowTooltip, children: /* @__PURE__ */ jsx(Button.Star, { "data-testid": "ds-table-star-button", active: isStarred(keyString), onClick: (e) => {
+      const newStarredRowKeys = toggleStarred(keyString);
+      if (typeof rowStar?.onChange === "function") {
+        rowStar.onChange(newStarredRowKeys, keyString, isStarred(keyString));
       }
-    };
-  };
-};
-export var useRowStar = function useRowStar(initialStarredKeys) {
-  var starredKeys = React.useRef(new Set(initialStarredKeys));
-  var getStarredRowKeys = function getStarredRowKeys() {
-    return Array.from(starredKeys.current);
-  };
-  var isStarred = React.useCallback(function (key) {
-    return starredKeys.current.has(key);
-  }, [starredKeys]);
-  var toggleStarred = React.useCallback(function (key) {
+      if (typeof rowStar?.onClick === "function") {
+        rowStar.onClick(e);
+      }
+    } }) });
+  })
+});
+const useRowStar = (initialStarredKeys) => {
+  const starredKeys = React.useRef(new Set(initialStarredKeys));
+  const getStarredRowKeys = () => Array.from(starredKeys.current);
+  const isStarred = React.useCallback((key) => starredKeys.current.has(key), [starredKeys]);
+  const toggleStarred = React.useCallback((key) => {
     if (starredKeys.current.has(key)) {
-      starredKeys.current["delete"](key);
+      starredKeys.current.delete(key);
     } else {
       starredKeys.current.add(key);
     }
     return getStarredRowKeys();
   }, [starredKeys]);
-  var getRowStarColumn = React.useMemo(function () {
-    return createRowStarColumn({
-      isStarred: isStarred,
-      toggleStarred: toggleStarred
-    });
-  }, [isStarred, toggleStarred]);
+  const getRowStarColumn = React.useMemo(() => createRowStarColumn({
+    isStarred,
+    toggleStarred
+  }), [isStarred, toggleStarred]);
   return {
     getStarredKeys: getStarredRowKeys,
-    isStarred: isStarred,
-    toggleStarred: toggleStarred,
-    getRowStarColumn: getRowStarColumn
+    isStarred,
+    toggleStarred,
+    getRowStarColumn
   };
-};
+};
+export {
+  useRowStar
+};

package/dist/hooks/useRowStar/useRowStar.types.d.ts

@@ -1,5 +1,5 @@
-import type React from 'react';
-import { type DSColumnType, type DSTableProps } from '../../Table.types';
+import { default as React } from 'react';
+import { DSColumnType, DSTableProps } from '../../Table.types';
 export type AnyRecordType = any;
 export interface UseStarredApi {
     getStarredKeys: () => string[];

package/dist/hooks/useRowStar/useRowStar.types.js

@@ -1 +1 @@
-export {};
+

package/dist/index.d.ts

@@ -1,8 +1,8 @@
+import { default as GroupedTable } from './GroupTable/GroupTable';
+import { default as ItemsMenu } from './ItemsMenu/ItemsMenu';
+import { default as TreeTable } from './TreeTable/TreeTable';
+import { default as VirtualTable } from './VirtualTable/VirtualTable';
 import * as TableCell from './Cell';
-import GroupedTable from './GroupTable/GroupTable';
-import ItemsMenu from './ItemsMenu/ItemsMenu';
-import TreeTable from './TreeTable/TreeTable';
-import VirtualTable from './VirtualTable/VirtualTable';
 export { default } from './Table';
 export { GroupedTable, VirtualTable, TableCell, ItemsMenu, TreeTable };
 export { default as BackToTopButton } from './InfiniteScroll/BackToTopButton';

package/dist/index.js

@@ -1,9 +1,18 @@
-import * as TableCell from './Cell';
-import GroupedTable from './GroupTable/GroupTable';
-import ItemsMenu from './ItemsMenu/ItemsMenu';
-import TreeTable from './TreeTable/TreeTable';
-import VirtualTable from './VirtualTable/VirtualTable';
-export { default } from './Table';
-export { GroupedTable, VirtualTable, TableCell, ItemsMenu, TreeTable };
-export { default as BackToTopButton } from './InfiniteScroll/BackToTopButton';
-export { GROUP_BY } from './GroupTable/GroupTable.types';
+import * as Cell_index from "./Cell/index.js";
+import { default as default2 } from "./GroupTable/GroupTable.js";
+import { default as default3 } from "./ItemsMenu/ItemsMenu.js";
+import { default as default4 } from "./TreeTable/TreeTable.js";
+import { default as default5 } from "./VirtualTable/VirtualTable.js";
+import { default as default6 } from "./Table.js";
+import { BackToTopButton } from "./InfiniteScroll/BackToTopButton.js";
+import { GROUP_BY } from "./GroupTable/GroupTable.types.js";
+export {
+  BackToTopButton,
+  GROUP_BY,
+  default2 as GroupedTable,
+  default3 as ItemsMenu,
+  Cell_index as TableCell,
+  default4 as TreeTable,
+  default5 as VirtualTable,
+  default6 as default
+};

package/dist/modules.d.js

@@ -1 +1 @@
-import '@testing-library/jest-dom';
+import "@testing-library/jest-dom";

package/dist/utils/calculateColumnWidths.d.ts

@@ -1,2 +1,2 @@
-import { type VirtualColumnType } from '../VirtualTable/VirtualTable.types';
+import { VirtualColumnType } from '../VirtualTable/VirtualTable.types';
 export declare const calculateColumnWidths: <T extends object>(columns: VirtualColumnType<T>[], availableSpace: number) => number[];

package/dist/utils/calculateColumnWidths.js

@@ -1,10 +1,10 @@
-import { calculatePixels } from './calculatePixels';
-export var calculateColumnWidths = function calculateColumnWidths(columns, availableSpace) {
-  var baseSum = 0;
-  var flexibleColumnCount = 0;
-  var noMaxColumnCount = 0;
-  var baseWidths = columns.map(function (column) {
-    var baseWidth = calculatePixels(column.width || column.minWidth) || 0;
+import { calculatePixels } from "./calculatePixels.js";
+const calculateColumnWidths = (columns, availableSpace) => {
+  let baseSum = 0;
+  let flexibleColumnCount = 0;
+  let noMaxColumnCount = 0;
+  const baseWidths = columns.map((column) => {
+    const baseWidth = calculatePixels(column.width || column.minWidth) || 0;
     flexibleColumnCount += Number(!column.width);
     noMaxColumnCount += Number(!column.width && !column.maxWidth);
     baseSum += baseWidth;
@@ -14,20 +14,18 @@ export var calculateColumnWidths = function calculateColumnWidths(columns, avail
     return baseWidths;
   }
   if (baseSum < availableSpace) {
-    // split remaining space across columns with minWidth
-    var extraWidth = (availableSpace - baseSum) / flexibleColumnCount;
-    var interimSum = 0;
-    columns.forEach(function (column, index) {
+    const extraWidth = (availableSpace - baseSum) / flexibleColumnCount;
+    let interimSum = 0;
+    columns.forEach((column, index) => {
       if (!column.width) {
-        var maxWidthAsNumber = calculatePixels(column.maxWidth);
+        const maxWidthAsNumber = calculatePixels(column.maxWidth);
         baseWidths[index] = maxWidthAsNumber ? Math.min(maxWidthAsNumber, baseWidths[index] + extraWidth) : baseWidths[index] + extraWidth;
       }
       interimSum += baseWidths[index];
     });
     if (interimSum < availableSpace) {
-      // split the remainder across columns with no maxWidth
-      var extraWidth2 = (availableSpace - interimSum) / noMaxColumnCount;
-      columns.forEach(function (column, index) {
+      const extraWidth2 = (availableSpace - interimSum) / noMaxColumnCount;
+      columns.forEach((column, index) => {
         if (!column.width && !column.maxWidth) {
           baseWidths[index] += extraWidth2;
         }
@@ -35,4 +33,7 @@ export var calculateColumnWidths = function calculateColumnWidths(columns, avail
     }
   }
   return baseWidths;
-};
+};
+export {
+  calculateColumnWidths
+};

package/dist/utils/calculatePixels.js

@@ -1,22 +1,21 @@
-// @ts-expect-error no types
-import toPx from 'unit-to-px';
-var hasSameLength = function hasSameLength(parsedValue, originalValue) {
-  return ("" + parsedValue).length === ("" + originalValue).length;
-};
-export var calculatePixels = function calculatePixels(value) {
-  if (typeof value === 'number') {
+import toPx from "unit-to-px";
+const hasSameLength = (parsedValue, originalValue) => `${parsedValue}`.length === `${originalValue}`.length;
+const calculatePixels = (value) => {
+  if (typeof value === "number") {
     return value;
   }
-  var isWhiteSpaceString = typeof value === 'string' && !value.trim();
+  const isWhiteSpaceString = typeof value === "string" && !value.trim();
   if (!value || isWhiteSpaceString) {
     return 0;
   }
-  // detect strings like "42" and convert to number
-  if (typeof value !== 'number' && !Number.isNaN(value) && !Number.isNaN(parseFloat(value))) {
-    var parsedNumber = parseFloat(value);
+  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/columnWithCellTooltip.d.ts

@@ -1,2 +1,2 @@
-import { type DSColumnType } from '../Table.types';
+import { DSColumnType } from '../Table.types';
 export declare const columnWithCellTooltip: <T extends object>(column: DSColumnType<T>) => DSColumnType<T>;

package/dist/utils/columnWithCellTooltip.js

@@ -1,22 +1,25 @@
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-import React from 'react';
-import Tooltip from '@synerise/ds-tooltip';
-import { EXPANDED_ROW_PROPERTY } from '../VirtualTable/constants';
-import { getValueFromPath } from './getValueFromPath';
-export var columnWithCellTooltip = function columnWithCellTooltip(column) {
+import { jsx, Fragment } from "react/jsx-runtime";
+import Tooltip from "@synerise/ds-tooltip";
+import { EXPANDED_ROW_PROPERTY } from "../VirtualTable/constants.js";
+import { getValueFromPath } from "./getValueFromPath.js";
+const columnWithCellTooltip = (column) => {
   if (!column.getCellTooltipProps) {
     return column;
   }
-  var renderColumn = function renderColumn(value, rowData, columnIndex) {
-    var cellTooltip = column.getCellTooltipProps == null ? void 0 : column.getCellTooltipProps(rowData);
+  const renderColumn = (value, rowData, columnIndex) => {
+    const cellTooltip = column.getCellTooltipProps?.(rowData);
     if (rowData[EXPANDED_ROW_PROPERTY] && column.childRender) {
-      var _content = column.childRender(getValueFromPath(rowData, column.dataIndex), rowData, columnIndex);
-      return cellTooltip ? /*#__PURE__*/React.createElement(Tooltip, cellTooltip, _content) : _content;
+      const content2 = column.childRender(getValueFromPath(rowData, column.dataIndex), rowData, columnIndex);
+      return cellTooltip ? /* @__PURE__ */ jsx(Tooltip, { ...cellTooltip, children: content2 }) : content2;
     }
-    var content = column.render ? column.render(getValueFromPath(rowData, column.dataIndex), rowData, columnIndex) : getValueFromPath(rowData, column.dataIndex);
-    return cellTooltip ? /*#__PURE__*/React.createElement(Tooltip, cellTooltip, /*#__PURE__*/React.createElement(React.Fragment, null, content)) : /*#__PURE__*/React.createElement(React.Fragment, null, content);
+    const content = column.render ? column.render(getValueFromPath(rowData, column.dataIndex), rowData, columnIndex) : getValueFromPath(rowData, column.dataIndex);
+    return cellTooltip ? /* @__PURE__ */ jsx(Tooltip, { ...cellTooltip, children: /* @__PURE__ */ jsx(Fragment, { children: content }) }) : /* @__PURE__ */ jsx(Fragment, { children: content });
   };
-  return _extends({}, column, {
+  return {
+    ...column,
     render: renderColumn
-  });
-};
+  };
+};
+export {
+  columnWithCellTooltip
+};

package/dist/utils/getChildrenColumnName.js

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

package/dist/utils/getRecordSelectionStatus.d.ts

@@ -1,4 +1,4 @@
-import { type RowSelection } from '../Table.types';
+import { RowSelection } from '../Table.types';
 export declare const getRecordSelectionStatus: <T>(checkRowSelectionStatus: RowSelection<T>["checkRowSelectionStatus"], record: T) => {
     unavailable: boolean | undefined;
     disabled: boolean | undefined;

package/dist/utils/getRecordSelectionStatus.js

@@ -1,9 +1,13 @@
-export var getRecordSelectionStatus = function getRecordSelectionStatus(checkRowSelectionStatus, record) {
-  var _ref = checkRowSelectionStatus && checkRowSelectionStatus(record) || {},
-    unavailable = _ref.unavailable,
-    disabled = _ref.disabled;
+const getRecordSelectionStatus = (checkRowSelectionStatus, record) => {
+  const {
+    unavailable,
+    disabled
+  } = checkRowSelectionStatus && checkRowSelectionStatus(record) || {};
   return {
-    unavailable: unavailable,
-    disabled: disabled
+    unavailable,
+    disabled
   };
-};
+};
+export {
+  getRecordSelectionStatus
+};

package/dist/utils/getSkeletonProps.d.ts

@@ -1,2 +1,2 @@
-import type { DSColumnType, DSTableProps } from '../Table.types';
+import { DSColumnType, DSTableProps } from '../Table.types';
 export declare const getSkeletonProps: <T extends object>(skeletonProps: DSTableProps<T>["skeletonProps"], columns?: DSColumnType<T>[]) => Partial<DSTableProps<T>>;