@synerise/ds-table 1.9.10 → 1.9.12

package/dist/ColumnSortMenu/columnWithSortButtons.d.ts

@@ -1,5 +1,4 @@
-import { type DSColumnType, type OnSortFn, type SortStateAPI } from '../Table.types';
-import './useSortState';
+import { DSColumnType, OnSortFn, SortStateAPI } from '../Table.types';
 export declare const columnWithSortButtons: (sortStateApi: SortStateAPI, onSort?: OnSortFn) => <T>(column: DSColumnType<T>) => DSColumnType<T>;
 declare const _default: {
     columnWithSortButtons: (sortStateApi: SortStateAPI, onSort?: OnSortFn) => <T>(column: DSColumnType<T>) => DSColumnType<T>;

package/dist/ColumnSortMenu/columnWithSortButtons.js

@@ -1,50 +1,33 @@
-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 { CommonRenderer, StringRenderer } from './SortRenderer';
-import { TitleWithSort } from './TitleWithSort';
-import './useSortState';
-var getSortRenderer = function getSortRenderer(sortRender, onSort) {
-  if (sortRender === void 0) {
-    sortRender = 'default';
-  }
-  if (typeof sortRender === 'function') {
+import { jsx } from "react/jsx-runtime";
+import { CommonRenderer, StringRenderer } from "./SortRenderer.js";
+import { TitleWithSort } from "./TitleWithSort.js";
+import "lodash.groupby";
+import "lodash.merge";
+import "react";
+const getSortRenderer = (sortRender = "default", onSort) => {
+  if (typeof sortRender === "function") {
     return sortRender;
   }
   switch (sortRender) {
-    case 'string':
-      return function (sortStateApi, column) {
-        return /*#__PURE__*/React.createElement(StringRenderer, {
-          sortStateApi: sortStateApi,
-          column: column,
-          onSort: onSort
-        });
-      };
-    case 'default':
+    case "string":
+      return (sortStateApi, column) => /* @__PURE__ */ jsx(StringRenderer, { sortStateApi, column, onSort });
+    case "default":
     default:
-      return function (sortStateApi, column) {
-        return /*#__PURE__*/React.createElement(CommonRenderer, {
-          sortStateApi: sortStateApi,
-          column: column,
-          onSort: onSort
-        });
-      };
+      return (sortStateApi, column) => /* @__PURE__ */ jsx(CommonRenderer, { sortStateApi, column, onSort });
   }
 };
-export var columnWithSortButtons = function columnWithSortButtons(sortStateApi, onSort) {
-  return function (column) {
-    var sortRenderer = getSortRenderer(column.sortRender, onSort);
-    return column.sorter ? _extends({}, column, {
-      sortOrder: column.key ? sortStateApi.getColumnSortOrder(String(column.key)) : null,
-      title: function title(titleProps) {
-        return /*#__PURE__*/React.createElement(TitleWithSort, {
-          column: column,
-          sortRender: sortRenderer(sortStateApi, column),
-          titleProps: titleProps
-        });
-      }
-    }) : column;
-  };
+const columnWithSortButtons = (sortStateApi, onSort) => (column) => {
+  const sortRenderer = getSortRenderer(column.sortRender, onSort);
+  return column.sorter ? {
+    ...column,
+    sortOrder: column.key ? sortStateApi.getColumnSortOrder(String(column.key)) : null,
+    title: (titleProps) => /* @__PURE__ */ jsx(TitleWithSort, { column, sortRender: sortRenderer(sortStateApi, column), titleProps })
+  } : column;
+};
+const columnWithSortButtons_default = {
+  columnWithSortButtons
+};
+export {
+  columnWithSortButtons,
+  columnWithSortButtons_default as default
 };
-export default {
-  columnWithSortButtons: columnWithSortButtons
-};

package/dist/ColumnSortMenu/groupedColumnsSort.d.ts

@@ -1,6 +1,6 @@
-import { type CompareFn } from 'antd/lib/table/interface';
-import { type GroupType } from '../GroupTable/GroupTable.types';
-import { type ColumnSortOrder, type DSColumnType, type SortStateAPI } from '../Table.types';
+import { CompareFn } from 'antd/lib/table/interface';
+import { GroupType } from '../GroupTable/GroupTable.types';
+import { ColumnSortOrder, DSColumnType, SortStateAPI } from '../Table.types';
 export declare const getColumnsWithActiveSorting: <T extends GroupType<T>>(sortStateApi: SortStateAPI, columns?: DSColumnType<T>[]) => DSColumnType<T>[];
 export declare const sortRows: <T>(sortOrder: ColumnSortOrder, compareFn: CompareFn<T>, rows: T[]) => T[];
 export declare const sortDataSourceRows: <T extends GroupType<T>>(sortStateApi: SortStateAPI, sortingColumns?: DSColumnType<T>[], dataSource?: readonly T[]) => readonly T[];

package/dist/ColumnSortMenu/groupedColumnsSort.js

@@ -1,42 +1,47 @@
-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); }
-export var getColumnsWithActiveSorting = function getColumnsWithActiveSorting(sortStateApi, columns) {
-  return !columns ? [] : columns.filter(function (_ref) {
-    var key = _ref.key,
-      sorter = _ref.sorter;
-    if (sortStateApi.getColumnSortOrder(String(key)) && typeof sorter === 'function') {
-      return true;
-    }
-    return false;
-  });
-};
-export var sortRows = function sortRows(sortOrder, compareFn, rows) {
-  if (sortOrder === 'ascend') {
-    return [].concat(rows).sort(compareFn);
+const getColumnsWithActiveSorting = (sortStateApi, columns) => !columns ? [] : columns.filter(({
+  key,
+  sorter
+}) => {
+  if (sortStateApi.getColumnSortOrder(String(key)) && typeof sorter === "function") {
+    return true;
+  }
+  return false;
+});
+const sortRows = (sortOrder, compareFn, rows) => {
+  if (sortOrder === "ascend") {
+    return [...rows].sort(compareFn);
   }
-  if (sortOrder === 'descend') {
-    return [].concat(rows).sort(compareFn).reverse();
+  if (sortOrder === "descend") {
+    return [...rows].sort(compareFn).reverse();
   }
   return rows;
 };
-export var sortDataSourceRows = function sortDataSourceRows(sortStateApi, sortingColumns, dataSource) {
+const sortDataSourceRows = (sortStateApi, sortingColumns, dataSource) => {
   if (!dataSource) {
     return [];
   }
-  if (!(sortingColumns != null && sortingColumns.length)) {
+  if (!sortingColumns?.length) {
     return dataSource;
   }
-  return dataSource == null ? void 0 : dataSource.map(function (dataItem) {
-    var sortedRows = sortingColumns.reduce(function (currRows, _ref2) {
-      var sorter = _ref2.sorter,
-        key = _ref2.key;
-      var sortOrder = sortStateApi.getColumnSortOrder(String(key));
-      if (!sortOrder || typeof sorter !== 'function') {
+  return dataSource?.map((dataItem) => {
+    const sortedRows = sortingColumns.reduce((currRows, {
+      sorter,
+      key
+    }) => {
+      const sortOrder = sortStateApi.getColumnSortOrder(String(key));
+      if (!sortOrder || typeof sorter !== "function") {
         return currRows;
       }
       return sortRows(sortOrder, sorter, currRows);
-    }, [].concat(dataItem.rows));
-    return _extends({}, dataItem, {
+    }, [...dataItem.rows]);
+    return {
+      ...dataItem,
       rows: sortedRows
-    });
+    };
   });
-};
+};
+export {
+  getColumnsWithActiveSorting,
+  sortDataSourceRows,
+  sortRows
+};

package/dist/ColumnSortMenu/replaceSortButtons.d.ts

@@ -1,3 +1,3 @@
-import type { ReactNode, ReactPortal } from 'react';
+import { ReactNode, ReactPortal } from 'react';
 declare const createReplaceButtonsPortal: <T extends Element>(columnTitleElement: T | null, newButtonsNode: ReactNode) => () => ReactPortal | null;
 export default createReplaceButtonsPortal;

package/dist/ColumnSortMenu/replaceSortButtons.js

@@ -1,16 +1,15 @@
-import { createPortal } from 'react-dom';
-var createReplaceButtonsPortal = function createReplaceButtonsPortal(columnTitleElement, newButtonsNode) {
-  return function () {
-    var _columnTitleElement$p;
-    var sortContainerElem = columnTitleElement == null || (_columnTitleElement$p = columnTitleElement.parentElement) == null ? void 0 : _columnTitleElement$p.nextSibling;
-    if (!sortContainerElem) {
-      return null;
-    }
-    var sortInnerElem = sortContainerElem.querySelector('.ant-table-column-sorter-inner');
-    if (sortInnerElem) {
-      sortContainerElem.removeChild(sortInnerElem);
-    }
-    return /*#__PURE__*/createPortal(newButtonsNode, sortContainerElem);
-  };
+import { createPortal } from "react-dom";
+const createReplaceButtonsPortal = (columnTitleElement, newButtonsNode) => () => {
+  const sortContainerElem = columnTitleElement?.parentElement?.nextSibling;
+  if (!sortContainerElem) {
+    return null;
+  }
+  const sortInnerElem = sortContainerElem.querySelector(".ant-table-column-sorter-inner");
+  if (sortInnerElem) {
+    sortContainerElem.removeChild(sortInnerElem);
+  }
+  return createPortal(newButtonsNode, sortContainerElem);
+};
+export {
+  createReplaceButtonsPortal as default
 };
-export default createReplaceButtonsPortal;

package/dist/ColumnSortMenu/useSortState.d.ts

@@ -1,4 +1,4 @@
-import { type ColumnSortOrder, type ColumnsSortState, type DSColumnType, type OnSortFn, type SortStateAPI } from '../Table.types';
+import { ColumnSortOrder, ColumnsSortState, DSColumnType, OnSortFn, SortStateAPI } from '../Table.types';
 export declare const toSortOrder: (value: string | null | undefined) => ColumnSortOrder;
 export declare const columnsToSortState: <T>(columns?: DSColumnType<T>[]) => ColumnsSortState;
 export declare const useSortState: (initialState: ColumnsSortState | undefined, onSort: OnSortFn | undefined) => SortStateAPI;

package/dist/ColumnSortMenu/useSortState.js

@@ -1,148 +1,150 @@
-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 groupBy from 'lodash.groupby';
-import merge from 'lodash.merge';
-import React from 'react';
-export var toSortOrder = function toSortOrder(value) {
-  if (value === 'descend' || value === 'ascend') {
+import "lodash.groupby";
+import merge from "lodash.merge";
+import React from "react";
+const toSortOrder = (value) => {
+  if (value === "descend" || value === "ascend") {
     return value;
   }
   return null;
 };
-export var columnsToSortState = function columnsToSortState(columns) {
-  if (columns === void 0) {
-    columns = [];
-  }
-  if (process.env.NODE_ENV === 'development') {
-    var columnsKeys = columns.map(function (c, i) {
-      if (c.sorter && !c.key) {
-        // eslint-disable-next-line no-console
-        console.warn("DefaultTable: column " + (typeof c.title === 'string' ? c.title : i + 1) + " has no \"key\" prop set which is required to use sorter");
-      }
-      return c.key;
-    });
-    var uniqueColumnKeys = Array.from(new Set(columnsKeys));
-    if (columnsKeys.length !== uniqueColumnKeys.length) {
-      // eslint-disable-next-line no-console
-      console.warn('DefaultTable: column keys are not unique what may affect sorting. Columns grouped by key:', groupBy(columns, 'key'));
-    }
-  }
-  return columns.reduce(function (state, column) {
-    var _extends2, _extends3;
-    return typeof column.sorter === 'object' ? _extends({}, state, (_extends2 = {}, _extends2[String(column.key)] = {
+const columnsToSortState = (columns = []) => {
+  return columns.reduce((state, column) => typeof column.sorter === "object" ? {
+    ...state,
+    [String(column.key)]: {
       sortOrder: toSortOrder(column.sortOrder) || toSortOrder(column.defaultSortOrder),
       multiple: column.sorter.multiple || false
-    }, _extends2)) : _extends({}, state, (_extends3 = {}, _extends3[String(column.key)] = {
+    }
+  } : {
+    ...state,
+    [String(column.key)]: {
       sortOrder: toSortOrder(column.sortOrder) || toSortOrder(column.defaultSortOrder),
       multiple: false
-    }, _extends3));
+    }
   }, {});
 };
-var setSingleOrder = function setSingleOrder(state, action) {
-  var _extends5;
-  var payload = action.payload;
-  var onSort = payload.onSort;
-  var clearedSortState = Object.entries(state).reduce(function (newState, _ref) {
-    var _extends4;
-    var currKey = _ref[0],
-      currValue = _ref[1];
-    return _extends({}, newState, (_extends4 = {}, _extends4[currKey] = _extends({}, currValue, {
+const setSingleOrder = (state, action) => {
+  const {
+    payload
+  } = action;
+  const {
+    onSort
+  } = payload;
+  const clearedSortState = Object.entries(state).reduce((newState2, [currKey, currValue]) => ({
+    ...newState2,
+    [currKey]: {
+      ...currValue,
       sortOrder: null
-    }), _extends4));
-  }, {});
-  var newState = _extends({}, clearedSortState, (_extends5 = {}, _extends5[payload.key] = _extends({}, state[payload.key], {
-    sortOrder: payload.sortOrder
-  }), _extends5));
+    }
+  }), {});
+  const newState = {
+    ...clearedSortState,
+    [payload.key]: {
+      ...state[payload.key],
+      sortOrder: payload.sortOrder
+    }
+  };
   onSort && onSort({
     columnKey: payload.key,
     order: payload.sortOrder
   }, newState);
   return newState;
 };
-var setMultipleOrder = function setMultipleOrder(state, action) {
-  var _extends8;
-  var payload = action.payload;
-  var onSort = payload.onSort;
-  var clearedSortState = Object.entries(state).reduce(function (newState, _ref2) {
-    var _extends6, _extends7;
-    var currKey = _ref2[0],
-      currValue = _ref2[1];
-    return currValue.multiple === false ? _extends({}, newState, (_extends6 = {}, _extends6[currKey] = _extends({}, currValue, {
+const setMultipleOrder = (state, action) => {
+  const {
+    payload
+  } = action;
+  const {
+    onSort
+  } = payload;
+  const clearedSortState = Object.entries(state).reduce((newState2, [currKey, currValue]) => currValue.multiple === false ? {
+    ...newState2,
+    [currKey]: {
+      ...currValue,
       sortOrder: null
-    }), _extends6)) : _extends({}, newState, (_extends7 = {}, _extends7[currKey] = state[currKey], _extends7));
+    }
+  } : {
+    ...newState2,
+    [currKey]: state[currKey]
   }, {});
-  var newState = _extends({}, clearedSortState, (_extends8 = {}, _extends8[payload.key] = _extends({}, state[payload.key], {
-    sortOrder: payload.sortOrder
-  }), _extends8));
+  const newState = {
+    ...clearedSortState,
+    [payload.key]: {
+      ...state[payload.key],
+      sortOrder: payload.sortOrder
+    }
+  };
   onSort && onSort({
     columnKey: payload.key,
     order: payload.sortOrder
   }, newState);
   return newState;
 };
-var updateColumns = function updateColumns(state, action) {
-  var payload = action.payload;
+const updateColumns = (state, action) => {
+  const {
+    payload
+  } = action;
   return merge(payload.columns, state);
 };
-var sortReducer = function sortReducer(state, action) {
-  var type = action.type;
+const sortReducer = (state, action) => {
+  const {
+    type
+  } = action;
   switch (type) {
-    case 'setSingleOrder':
+    case "setSingleOrder":
       return setSingleOrder(state, action);
-    case 'setMultipleOrder':
+    case "setMultipleOrder":
       return setMultipleOrder(state, action);
-    case 'updateColumns':
+    case "updateColumns":
       return updateColumns(state, action);
     default:
       return state;
   }
 };
-export var useSortState = function useSortState(initialState, onSort) {
-  if (initialState === void 0) {
-    initialState = {};
-  }
-  var _React$useReducer = React.useReducer(sortReducer, initialState),
-    columnsSortState = _React$useReducer[0],
-    dispatch = _React$useReducer[1];
-  var getColumnSortOrder = function getColumnSortOrder(key) {
-    var _columnsSortState$key;
-    return (_columnsSortState$key = columnsSortState[key]) == null ? void 0 : _columnsSortState$key.sortOrder;
+const useSortState = (initialState = {}, onSort) => {
+  const [columnsSortState, dispatch] = React.useReducer(sortReducer, initialState);
+  const getColumnSortOrder = (key) => {
+    return columnsSortState[key]?.sortOrder;
   };
-  var updateColumnsData = function updateColumnsData(columns) {
+  const updateColumnsData = (columns) => {
     dispatch({
-      type: 'updateColumns',
+      type: "updateColumns",
       payload: {
-        columns: columns
+        columns
       }
     });
   };
-  var setColumnSortOrder = function setColumnSortOrder(key, sortOrder) {
-    var _columnsSortState$key2, _columnsSortState$key3, _columnsSortState$key4, _columnsSortState$key5;
-    if (((_columnsSortState$key2 = columnsSortState[key]) == null ? void 0 : _columnsSortState$key2.sortOrder) !== sortOrder && ((_columnsSortState$key3 = columnsSortState[key]) == null ? void 0 : _columnsSortState$key3.multiple) === false) {
+  const setColumnSortOrder = (key, sortOrder) => {
+    if (columnsSortState[key]?.sortOrder !== sortOrder && columnsSortState[key]?.multiple === false) {
       dispatch({
-        type: 'setSingleOrder',
+        type: "setSingleOrder",
         payload: {
-          key: key,
-          sortOrder: sortOrder,
-          onSort: onSort
+          key,
+          sortOrder,
+          onSort
         }
       });
     }
-    if (((_columnsSortState$key4 = columnsSortState[key]) == null ? void 0 : _columnsSortState$key4.sortOrder) !== sortOrder && (_columnsSortState$key5 = columnsSortState[key]) != null && _columnsSortState$key5.multiple) {
+    if (columnsSortState[key]?.sortOrder !== sortOrder && columnsSortState[key]?.multiple) {
       dispatch({
-        type: 'setMultipleOrder',
+        type: "setMultipleOrder",
         payload: {
-          key: key,
-          sortOrder: sortOrder,
-          onSort: onSort
+          key,
+          sortOrder,
+          onSort
         }
       });
     }
   };
   return {
-    columnsSortState: columnsSortState,
-    updateColumnsData: updateColumnsData,
-    getColumnSortOrder: getColumnSortOrder,
-    setColumnSortOrder: setColumnSortOrder
+    columnsSortState,
+    updateColumnsData,
+    getColumnSortOrder,
+    setColumnSortOrder
   };
 };
-export default useSortState;
+export {
+  columnsToSortState,
+  useSortState as default,
+  toSortOrder,
+  useSortState
+};

package/dist/DefaultTable/DefaultTable.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
-import { type DSTableProps, type RowType } from '../Table.types';
+import { default as React } from 'react';
+import { DSTableProps, RowType } from '../Table.types';
 declare function DefaultTable<T extends object & RowType<T>>(props: DSTableProps<T>): React.JSX.Element;
 export default DefaultTable;