@wavemaker-ai/react-runtime 1.0.0-next.27766

package/components/data/table/hooks/useTableEffects.js

@@ -0,0 +1,110 @@
+import { useEffect, useState } from "react";
+import { saveTableState, clearTableState, getTableState } from "../utils/table-helpers";
+import { UNSUPPORTED_STATE_PERSISTENCE_TYPES } from "../utils/constants";
+const useTableEffects = (props) => {
+  const {
+    name,
+    navigation,
+    datasource,
+    internalDataset,
+    statehandler,
+    selectedRowIds,
+    currentPage,
+    currentPageSize,
+    isGridEditMode,
+    stateManager
+  } = props;
+  const [hasRestoredState, setHasRestoredState] = useState(false);
+  const [restoredPageNumber, setRestoredPageNumber] = useState(null);
+  const [restoredSelectedRowIds, setRestoredSelectedRowIds] = useState([]);
+  const [restoredSelectedIndices, setRestoredSelectedIndices] = useState([]);
+  const [isRestoringSelection, setIsRestoringSelection] = useState(false);
+  useEffect(() => {
+    if (UNSUPPORTED_STATE_PERSISTENCE_TYPES.includes(navigation)) {
+      setHasRestoredState(true);
+      return;
+    }
+    if (!hasRestoredState && statehandler && internalDataset.length > 0) {
+      const savedState = getTableState(name, statehandler);
+      if (savedState) {
+        const hasActiveFilter = savedState.search && savedState.search.length > 0;
+        if (savedState.pagination && !hasActiveFilter) {
+          setRestoredPageNumber(savedState.pagination);
+        }
+        if (savedState.selectedItem && savedState.selectedItem.length > 0 && !hasActiveFilter) {
+          const restoredPage = savedState.pagination || 1;
+          const currentPageSelections = savedState.selectedItem.filter((item) => item.page === restoredPage).map((item) => item.index);
+          setRestoredSelectedIndices(currentPageSelections);
+        }
+      }
+      setHasRestoredState(true);
+    }
+  }, [name, statehandler, hasRestoredState, internalDataset.length, navigation]);
+  useEffect(() => {
+    if (UNSUPPORTED_STATE_PERSISTENCE_TYPES.includes(navigation)) {
+      return;
+    }
+    if (internalDataset.length === 0 || !statehandler) {
+      return;
+    }
+    if (isGridEditMode || isRestoringSelection) {
+      return;
+    }
+    if (datasource == null ? void 0 : datasource.loading) {
+      return;
+    }
+    if (!stateManager.isDefaultState()) {
+      const existingState = getTableState(name, statehandler);
+      const stateToSave = stateManager.mergeWithExisting(stateManager.currentState, existingState);
+      const cleanedState = {};
+      if (stateToSave.pagination && stateToSave.pagination !== 1) {
+        cleanedState.pagination = stateToSave.pagination;
+      }
+      if (stateToSave.pagesize) {
+        cleanedState.pagesize = stateToSave.pagesize;
+      }
+      if (stateToSave.selectedItem && stateToSave.selectedItem.length > 0) {
+        cleanedState.selectedItem = stateToSave.selectedItem;
+      }
+      if (stateToSave.search && stateToSave.search.length > 0) {
+        cleanedState.search = stateToSave.search;
+      }
+      if (stateToSave.sort) {
+        cleanedState.sort = stateToSave.sort;
+      }
+      if (stateToSave.actualpagesize !== void 0) {
+        cleanedState.actualpagesize = stateToSave.actualpagesize;
+      }
+      if (Object.keys(cleanedState).length > 0) {
+        clearTableState(name, statehandler);
+        saveTableState(name, statehandler, cleanedState);
+      } else {
+        clearTableState(name, statehandler);
+      }
+    } else {
+      clearTableState(name, statehandler);
+    }
+  }, [
+    selectedRowIds,
+    currentPage,
+    currentPageSize,
+    internalDataset,
+    name,
+    statehandler,
+    isGridEditMode,
+    isRestoringSelection,
+    stateManager,
+    navigation,
+    datasource == null ? void 0 : datasource.loading
+  ]);
+  return {
+    restoredPageNumber,
+    restoredSelectedRowIds,
+    restoredSelectedIndices,
+    hasRestoredState,
+    setIsRestoringSelection
+  };
+};
+export {
+  useTableEffects
+};

package/components/data/table/hooks/useTableFilter.d.ts

@@ -0,0 +1,26 @@
+import { TableFilterMode } from "../props";
+import { TableSearchFilter, FilterFieldsObject } from "../utils/table-helpers";
+interface UseTableFilterProps {
+    filterMode?: TableFilterMode;
+    columns: Array<Record<string, unknown>>;
+    dataset: Array<Record<string, unknown>>;
+    initialSearchState?: TableSearchFilter[];
+}
+interface ColumnFilter {
+    value: string | number | boolean | null;
+    matchMode: string;
+}
+interface UseTableFilterReturn {
+    globalFilter: string;
+    setGlobalFilter: (value: string) => void;
+    globalSearchColumn: string;
+    setGlobalSearchColumn: (columnId: string) => void;
+    columnFilters: Record<string, ColumnFilter>;
+    setColumnFilter: (columnId: string, value: string | number | boolean | null, matchMode?: string) => void;
+    filteredData: Array<Record<string, unknown>>;
+    clearAllFilters: () => void;
+    getFilterFields: (searchObj?: TableSearchFilter | TableSearchFilter[]) => FilterFieldsObject;
+    transformFilterFields: (filterFields: Record<string, unknown>) => TableSearchFilter[];
+}
+export declare const useTableFilter: ({ filterMode, columns, dataset, initialSearchState, }: UseTableFilterProps) => UseTableFilterReturn;
+export {};

package/components/data/table/hooks/useTableFilter.js

@@ -0,0 +1,396 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { useState, useCallback, useMemo } from "react";
+import {
+  get,
+  isEmpty,
+  toString,
+  toLower,
+  startsWith,
+  endsWith,
+  includes,
+  isEqual,
+  toNumber,
+  filter,
+  find,
+  forEach,
+  isArray,
+  isNull,
+  isNil,
+  isString,
+  map
+} from "lodash-es";
+import { DataType } from "../../types";
+const NUMERIC_DATA_TYPES = [
+  DataType.INTEGER,
+  DataType.BIG_INTEGER,
+  DataType.SHORT,
+  DataType.FLOAT,
+  DataType.BIG_DECIMAL,
+  DataType.DOUBLE,
+  DataType.LONG,
+  DataType.BYTE,
+  "number"
+];
+const DATE_DATA_TYPES = [DataType.DATE, DataType.TIME, DataType.TIMESTAMP, DataType.DATETIME];
+const MATCH_MODES = {
+  START: "start",
+  START_IGNORE_CASE: "startignorecase",
+  END: "end",
+  END_IGNORE_CASE: "endignorecase",
+  EXACT: "exact",
+  EXACT_IGNORE_CASE: "exactignorecase",
+  NOT_EQUALS: "notequals",
+  NOT_EQUALS_IGNORE_CASE: "notequalsignorecase",
+  NULL: "null",
+  IS_NOT_NULL: "isnotnull",
+  EMPTY: "empty",
+  IS_NOT_EMPTY: "isnotempty",
+  NULL_OR_EMPTY: "nullorempty",
+  LESS_THAN: "lessthan",
+  LESS_THAN_EQUAL: "lessthanequal",
+  GREATER_THAN: "greaterthan",
+  GREATER_THAN_EQUAL: "greaterthanequal",
+  ANYWHERE: "anywhere",
+  ANYWHERE_IGNORE_CASE: "anywhereignorecase"
+};
+const EMPTY_MATCH_MODES = [
+  MATCH_MODES.NULL,
+  MATCH_MODES.EMPTY,
+  MATCH_MODES.NULL_OR_EMPTY,
+  MATCH_MODES.IS_NOT_NULL,
+  MATCH_MODES.IS_NOT_EMPTY
+];
+const isNumberType = (type) => {
+  return includes(NUMERIC_DATA_TYPES, type == null ? void 0 : type.toLowerCase());
+};
+const getSearchValue = (value, type) => {
+  if (!value && value !== 0 && value !== "") {
+    return void 0;
+  }
+  const dataType = type == null ? void 0 : type.toLowerCase();
+  if (isNumberType(dataType != null ? dataType : "")) {
+    return toNumber(value);
+  }
+  if (includes(DATE_DATA_TYPES, dataType)) {
+    return new Date(value).valueOf();
+  }
+  return toLower(toString(value));
+};
+const getFilteredData = (data, searchObj, visibleCols = []) => {
+  var _a, _b;
+  const searchVal = getSearchValue(searchObj.value, searchObj.type);
+  let currentVal;
+  if (!searchVal && searchVal !== 0 && !includes(EMPTY_MATCH_MODES, (_a = searchObj.matchMode) != null ? _a : "") || isNumberType((_b = searchObj.type) != null ? _b : "") && isNull(searchObj.value)) {
+    return data;
+  }
+  return filter(data, (obj) => {
+    var _a2;
+    let isExists;
+    if (searchObj.field) {
+      currentVal = getSearchValue(get(obj, searchObj.field), searchObj.type);
+    } else {
+      const valuesArray = [];
+      forEach(obj, (val, key) => {
+        if (includes(visibleCols, key)) {
+          valuesArray.push(val);
+        } else {
+          const nestedColPaths = filter(visibleCols, (col) => startsWith(col, `${key}.`));
+          forEach(nestedColPaths, (colPath) => {
+            const value = get(obj, colPath);
+            if (!includes(valuesArray, value)) {
+              valuesArray.push(value);
+            }
+          });
+        }
+      });
+      currentVal = toLower(valuesArray.join(" "));
+    }
+    const hasValidValues = !isNil(currentVal) && !isNil(searchVal);
+    const isCurrentString = isString(currentVal);
+    const isSearchString = isString(searchVal);
+    const areBothStrings = isCurrentString && isSearchString;
+    switch (searchObj.matchMode) {
+      case MATCH_MODES.START:
+      case MATCH_MODES.START_IGNORE_CASE:
+        isExists = areBothStrings ? startsWith(currentVal, searchVal) : false;
+        break;
+      case MATCH_MODES.END:
+      case MATCH_MODES.END_IGNORE_CASE:
+        isExists = areBothStrings ? endsWith(currentVal, searchVal) : false;
+        break;
+      case MATCH_MODES.EXACT:
+      case MATCH_MODES.EXACT_IGNORE_CASE:
+        isExists = isEqual(currentVal, searchVal);
+        break;
+      case MATCH_MODES.NOT_EQUALS:
+      case MATCH_MODES.NOT_EQUALS_IGNORE_CASE:
+        isExists = !isEqual(currentVal, searchVal);
+        break;
+      case MATCH_MODES.NULL:
+        isExists = isNull(currentVal);
+        break;
+      case MATCH_MODES.IS_NOT_NULL:
+        isExists = !isNull(currentVal);
+        break;
+      case MATCH_MODES.EMPTY:
+        isExists = isEmpty(currentVal);
+        break;
+      case MATCH_MODES.IS_NOT_EMPTY:
+        isExists = !isEmpty(currentVal);
+        break;
+      case MATCH_MODES.NULL_OR_EMPTY:
+        isExists = isNull(currentVal) || isEmpty(currentVal);
+        break;
+      case MATCH_MODES.LESS_THAN:
+        isExists = hasValidValues && currentVal < searchVal;
+        break;
+      case MATCH_MODES.LESS_THAN_EQUAL:
+        isExists = hasValidValues && currentVal <= searchVal;
+        break;
+      case MATCH_MODES.GREATER_THAN:
+        isExists = hasValidValues && currentVal > searchVal;
+        break;
+      case MATCH_MODES.GREATER_THAN_EQUAL:
+        isExists = hasValidValues && currentVal >= searchVal;
+        break;
+      case MATCH_MODES.ANYWHERE:
+      case MATCH_MODES.ANYWHERE_IGNORE_CASE:
+      default:
+        isExists = isNumberType((_a2 = searchObj.type) != null ? _a2 : "") ? isEqual(currentVal, searchVal) : isCurrentString && !isNil(searchVal) ? includes(currentVal, toString(searchVal)) : false;
+        break;
+    }
+    return isExists;
+  });
+};
+const setFilterFields = (filterFields, searchObj, visibleCols = [], columns = []) => {
+  var _a, _b, _c, _d, _e, _f;
+  const field = searchObj && searchObj.field;
+  if (field) {
+    const column = find(columns, (col) => {
+      const c = col;
+      return c.accessorKey === field || c.id === field;
+    });
+    const columnType = (_e = (_d = (_b = searchObj.type) != null ? _b : (_a = column == null ? void 0 : column.meta) == null ? void 0 : _a.type) != null ? _d : (_c = column == null ? void 0 : column.meta) == null ? void 0 : _c.editinputtype) != null ? _e : DataType.STRING;
+    filterFields[field] = {
+      value: searchObj.value,
+      logicalOp: "AND",
+      matchMode: (_f = searchObj.matchMode) != null ? _f : MATCH_MODES.ANYWHERE_IGNORE_CASE,
+      type: columnType
+    };
+  } else {
+    forEach(visibleCols, (field2) => {
+      var _a2, _b2, _c2, _d2, _e2;
+      const column = find(columns, (col) => {
+        const c = col;
+        return c.accessorKey === field2;
+      });
+      const columnType = (_d2 = (_c2 = (_a2 = column == null ? void 0 : column.meta) == null ? void 0 : _a2.type) != null ? _c2 : (_b2 = column == null ? void 0 : column.meta) == null ? void 0 : _b2.editinputtype) != null ? _d2 : DataType.STRING;
+      filterFields[field2] = {
+        value: searchObj.value,
+        type: columnType,
+        logicalOp: "OR",
+        matchMode: (_e2 = searchObj.matchMode) != null ? _e2 : MATCH_MODES.ANYWHERE_IGNORE_CASE
+      };
+    });
+  }
+};
+const useTableFilter = ({
+  filterMode,
+  columns = [],
+  dataset = [],
+  initialSearchState
+}) => {
+  const getInitialGlobalFilter = () => {
+    if (!initialSearchState || filterMode !== "search") return "";
+    if (isArray(initialSearchState) && initialSearchState.length > 0) {
+      const value = initialSearchState[0].value;
+      return !isNil(value) ? String(value) : "";
+    }
+    return "";
+  };
+  const getInitialGlobalSearchColumn = () => {
+    if (!initialSearchState || filterMode !== "search") return "";
+    if (isArray(initialSearchState) && initialSearchState.length > 0) {
+      return initialSearchState[0].field || "";
+    }
+    return "";
+  };
+  const getInitialColumnFilters = () => {
+    if (!initialSearchState || filterMode !== "multicolumn") return {};
+    const filters = {};
+    if (isArray(initialSearchState)) {
+      forEach(initialSearchState, (filter2) => {
+        var _a, _b;
+        if (filter2.field) {
+          filters[filter2.field] = {
+            value: (_a = filter2.value) != null ? _a : "",
+            matchMode: (_b = filter2.matchMode) != null ? _b : MATCH_MODES.ANYWHERE_IGNORE_CASE
+          };
+        }
+      });
+    }
+    return filters;
+  };
+  const [globalFilter, setGlobalFilter] = useState(getInitialGlobalFilter());
+  const [globalSearchColumn, setGlobalSearchColumn] = useState(
+    getInitialGlobalSearchColumn()
+  );
+  const [columnFilters, setColumnFilters] = useState(getInitialColumnFilters());
+  const setColumnFilter = useCallback(
+    (columnId, value, matchMode = MATCH_MODES.ANYWHERE_IGNORE_CASE) => {
+      setColumnFilters((prev) => __spreadProps(__spreadValues({}, prev), {
+        [columnId]: {
+          value,
+          matchMode
+        }
+      }));
+    },
+    []
+  );
+  const clearAllFilters = useCallback(() => {
+    setGlobalFilter("");
+    setGlobalSearchColumn("");
+    setColumnFilters({});
+  }, []);
+  const getTableVisibleCols = useCallback(() => {
+    const excludedColumnIds = [
+      "actions",
+      "row-operations",
+      "multiSelect",
+      "radioSelect",
+      "row-index"
+    ];
+    return map(
+      filter(columns, (col) => {
+        const column = col;
+        return column.searchable !== false && !!column.accessorKey && !includes(excludedColumnIds, column.id);
+      }),
+      (col) => col.accessorKey
+    );
+  }, [columns]);
+  const getFilterFields = useCallback(
+    (searchObj) => {
+      const filterFields = {};
+      const visibleCols = getTableVisibleCols();
+      if (!searchObj) return filterFields;
+      if (isArray(searchObj)) {
+        forEach(searchObj, (obj) => {
+          setFilterFields(filterFields, obj, visibleCols, columns);
+        });
+      } else {
+        setFilterFields(filterFields, searchObj, visibleCols, columns);
+      }
+      return filterFields;
+    },
+    [getTableVisibleCols, columns]
+  );
+  const transformFilterFields = useCallback(
+    (filterFields) => {
+      const result = [];
+      forEach(filterFields, (filter2, field) => {
+        var _a, _b, _c;
+        const filterObj = filter2;
+        if (filterObj && (!isNil(filterObj.value) || includes(EMPTY_MATCH_MODES, (_a = filterObj.matchMode) != null ? _a : ""))) {
+          result.push({
+            field,
+            value: filterObj.value,
+            matchMode: (_b = filterObj.matchMode) != null ? _b : MATCH_MODES.ANYWHERE_IGNORE_CASE,
+            type: (_c = filterObj.type) != null ? _c : DataType.STRING
+          });
+        }
+      });
+      return result;
+    },
+    []
+  );
+  const filteredData = useMemo(() => {
+    if (!filterMode || !dataset) {
+      return dataset;
+    }
+    let data = [...dataset];
+    const visibleCols = getTableVisibleCols();
+    if (filterMode === "search") {
+      if (globalFilter || globalSearchColumn) {
+        const searchObj = {
+          field: globalSearchColumn || "",
+          value: globalFilter,
+          matchMode: MATCH_MODES.ANYWHERE_IGNORE_CASE,
+          type: globalSearchColumn ? (() => {
+            var _a, _b, _c, _d;
+            const col = find(columns, (c) => {
+              const column = c;
+              return column.accessorKey === globalSearchColumn || column.id === globalSearchColumn;
+            });
+            return (_d = (_c = (_a = col == null ? void 0 : col.meta) == null ? void 0 : _a.type) != null ? _c : (_b = col == null ? void 0 : col.meta) == null ? void 0 : _b.editinputtype) != null ? _d : DataType.STRING;
+          })() : DataType.STRING
+        };
+        data = getFilteredData(data, searchObj, visibleCols);
+      }
+    } else if (filterMode === "multicolumn") {
+      const filterArray = [];
+      forEach(columnFilters, (filterObj, columnId) => {
+        var _a, _b, _c, _d;
+        if (!filterObj) return;
+        if (isNil(filterObj.value) && !includes(EMPTY_MATCH_MODES, filterObj.matchMode)) return;
+        const column = find(columns, (col) => {
+          const c = col;
+          return c.id === columnId || c.accessorKey === columnId;
+        });
+        if (column && column.accessorKey) {
+          filterArray.push({
+            field: column.accessorKey,
+            value: filterObj.value,
+            matchMode: filterObj.matchMode,
+            type: (_d = (_c = (_a = column.meta) == null ? void 0 : _a.type) != null ? _c : (_b = column.meta) == null ? void 0 : _b.editinputtype) != null ? _d : DataType.STRING
+          });
+        }
+      });
+      data = filterArray.reduce(
+        (filteredData2, searchObj) => getFilteredData(filteredData2, searchObj, visibleCols),
+        data
+      );
+    }
+    return data;
+  }, [
+    dataset,
+    columns,
+    filterMode,
+    globalFilter,
+    globalSearchColumn,
+    columnFilters,
+    getTableVisibleCols
+  ]);
+  return {
+    globalFilter,
+    setGlobalFilter,
+    globalSearchColumn,
+    setGlobalSearchColumn,
+    columnFilters,
+    setColumnFilter,
+    filteredData,
+    clearAllFilters,
+    getFilterFields,
+    transformFilterFields
+  };
+};
+export {
+  useTableFilter
+};

package/components/data/table/hooks/useTableInitialization.d.ts

@@ -0,0 +1,5 @@
+import { UseTableInitializationProps } from "../props";
+/**
+ * Hook to handle table initialization and active row synchronization logic
+ */
+export declare const useTableInitialization: ({ internalDataset, wmTableColumns, cellState, gridfirstrowselect, useRadioSelect, useMultiSelect, setActiveRow, selectedRowIds, activeRowIds, formName, editmode, listener, }: UseTableInitializationProps) => void;

package/components/data/table/hooks/useTableInitialization.js

@@ -0,0 +1,73 @@
+import { useEffect } from "react";
+import { get } from "lodash-es";
+const useTableInitialization = ({
+  internalDataset,
+  wmTableColumns,
+  cellState,
+  gridfirstrowselect,
+  useRadioSelect,
+  useMultiSelect,
+  setActiveRow,
+  selectedRowIds,
+  activeRowIds,
+  formName,
+  editmode,
+  listener
+}) => {
+  useEffect(() => {
+    if (!internalDataset || internalDataset.length === 0) return;
+    const editableColumns = wmTableColumns.filter((col) => col.editWidgetType && !col.readonly);
+    internalDataset.forEach((row) => {
+      const rowId = row._wmTableRowId || String(row.id) || "";
+      editableColumns.forEach((column) => {
+        const fieldName = column.field;
+        const currentValue = get(row, fieldName);
+        cellState.setValue(["cells", rowId, fieldName], currentValue);
+      });
+    });
+  }, [internalDataset, wmTableColumns, cellState]);
+  useEffect(() => {
+    if (gridfirstrowselect && !useRadioSelect && !useMultiSelect && internalDataset.length > 0) {
+      const firstRowData = internalDataset[0];
+      const firstRowId = firstRowData._wmTableRowId || String(firstRowData.id) || String(0);
+      setActiveRow(firstRowId);
+    }
+  }, [gridfirstrowselect, useRadioSelect, useMultiSelect, internalDataset, setActiveRow]);
+  useEffect(() => {
+    if ((useMultiSelect || useRadioSelect) && selectedRowIds.length > 0) {
+      setActiveRow(selectedRowIds);
+    }
+  }, [selectedRowIds, useMultiSelect, useRadioSelect, setActiveRow]);
+  useEffect(() => {
+    const hasNoActiveRows = !activeRowIds || activeRowIds.length === 0;
+    if (hasNoActiveRows) {
+      if (listener && (editmode === "form" || editmode === "none") && formName) {
+        setTimeout(() => {
+          var _a;
+          (_a = listener.Widgets[formName]) == null ? void 0 : _a.setShowViewMode(true);
+        }, 10);
+      }
+    } else {
+      if (activeRowIds.length > 0 && listener && formName) {
+        setTimeout(() => {
+          var _a, _b, _c;
+          const formWidget = listener.Widgets[formName];
+          const getRow = internalDataset.find((row) => {
+            if (row._wmTableRowId === activeRowIds[0]) return true;
+          });
+          if (editmode === "none") {
+            (_a = formWidget == null ? void 0 : formWidget.setFormData) == null ? void 0 : _a.call(formWidget, getRow);
+            formWidget == null ? void 0 : formWidget.setShowViewMode(true);
+          } else if (editmode === "form") {
+            (_b = formWidget == null ? void 0 : formWidget.setFormData) == null ? void 0 : _b.call(formWidget, getRow);
+          } else {
+            (_c = formWidget == null ? void 0 : formWidget.edit) == null ? void 0 : _c.call(formWidget, getRow);
+          }
+        }, 10);
+      }
+    }
+  }, [activeRowIds, internalDataset, gridfirstrowselect]);
+};
+export {
+  useTableInitialization
+};

package/components/data/table/hooks/useTableState.d.ts

@@ -0,0 +1,2 @@
+import { UseTableStateProps, UseTableStateReturn } from "../props";
+export declare const useTableState: ({ editMode, radioselect, multiselect, }: UseTableStateProps) => UseTableStateReturn;

package/components/data/table/hooks/useTableState.js

@@ -0,0 +1,53 @@
+import { useState, useCallback } from "react";
+const useTableState = ({
+  editMode = "none",
+  radioselect = false,
+  multiselect = false
+}) => {
+  const [activeRowIds, setActiveRowIds] = useState([]);
+  const handleRowActiveClick = useCallback(
+    (rowId, isSelectionHandled, isEditingOrAdding) => {
+      if (isEditingOrAdding) {
+        return;
+      }
+      if (multiselect) {
+        return;
+      } else {
+        setActiveRowIds([rowId]);
+      }
+    },
+    [multiselect]
+  );
+  const isRowActive = useCallback(
+    (rowId, isSelected) => {
+      return activeRowIds && Array.isArray(activeRowIds) && activeRowIds.includes(rowId);
+    },
+    [activeRowIds]
+  );
+  const clearActiveRow = useCallback(() => {
+    setActiveRowIds([]);
+  }, []);
+  const setActiveRow = useCallback((rowIds) => {
+    if (rowIds === null) {
+      setActiveRowIds([]);
+    } else if (typeof rowIds === "string" || typeof rowIds === "number") {
+      setActiveRowIds([String(rowIds)]);
+    } else if (Array.isArray(rowIds)) {
+      setActiveRowIds(rowIds);
+    } else {
+      console.warn("Unexpected type for rowIds:", typeof rowIds, rowIds);
+      setActiveRowIds([]);
+    }
+  }, []);
+  const activeRowId = activeRowIds && activeRowIds.length > 0 ? activeRowIds[0] : null;
+  return {
+    activeRowIds,
+    setActiveRow,
+    clearActiveRow,
+    handleRowActiveClick,
+    isRowActive
+  };
+};
+export {
+  useTableState
+};