@itwin/itwinui-react 3.12.2 → 3.13.0

package/cjs/core/Table/hooks/useScrollToRow.js

@@ -17,34 +17,27 @@ function useScrollToRow({
   paginatorRenderer,
   scrollToRow,
 }) {
-  const rowRefs = _react.useRef({});
-  const pageRef = _react.useRef(page);
+  let rowRefs = _react.useRef({});
+  let pageRef = _react.useRef(page);
   pageRef.current = page;
-  const dataRef = _react.useRef(data);
+  let dataRef = _react.useRef(data);
   dataRef.current = data;
-  const scrollToIndex = _react.useMemo(() => {
-    if (!scrollToRow || paginatorRenderer) {
-      return undefined;
-    }
-    const index = scrollToRow(pageRef.current, dataRef.current);
-    return index < 0 ? undefined : index;
+  let scrollToIndex = _react.useMemo(() => {
+    if (!scrollToRow || paginatorRenderer) return;
+    let index = scrollToRow(pageRef.current, dataRef.current);
+    return index < 0 ? void 0 : index;
   }, [paginatorRenderer, scrollToRow]);
   _react.useEffect(() => {
-    if (
-      enableVirtualization ||
-      scrollToIndex === undefined ||
-      scrollToIndex === null ||
-      scrollToIndex < 0
-    ) {
+    if (enableVirtualization || null == scrollToIndex || scrollToIndex < 0)
       return;
-    }
     rowRefs.current[pageRef.current[scrollToIndex]?.id]?.scrollIntoView();
   }, [enableVirtualization, scrollToIndex]);
-  const tableRowRef = _react.useCallback((row) => {
-    return (element) => {
+  let tableRowRef = _react.useCallback(
+    (row) => (element) => {
       rowRefs.current[row.id] = element;
-    };
-  }, []);
+    },
+    [],
+  );
   return {
     scrollToIndex,
     tableRowRef,

package/cjs/core/Table/hooks/useSelectionCell.js

@@ -12,11 +12,9 @@ const _index = require('../columns/index.js');
 const useSelectionCell =
   (isSelectable, selectionMode, isRowDisabled, density = 'default') =>
   (hooks) => {
-    if (!isSelectable) {
-      return;
-    }
+    if (!isSelectable) return;
     hooks.allColumns.push((columns) =>
-      selectionMode === 'single' ||
+      'single' === selectionMode ||
       columns.find((c) => c.id === _index.SELECTION_CELL_ID)
         ? columns
         : [

package/cjs/core/Table/hooks/useStickyColumns.js

@@ -16,16 +16,15 @@ const useStickyColumns = (hooks) => {
   hooks.useInstance.push(useInstance);
 };
 const reducer = (newState, action) => {
-  if (action.type === _reacttable.actions.init) {
+  if (action.type === _reacttable.actions.init)
     return {
       ...newState,
       sticky: {},
     };
-  }
   if (
     action.type === _reacttable.actions.setScrolledLeft &&
     newState.sticky?.isScrolledToLeft !== action.value
-  ) {
+  )
     return {
       ...newState,
       sticky: {
@@ -33,11 +32,10 @@ const reducer = (newState, action) => {
         isScrolledToLeft: action.value,
       },
     };
-  }
   if (
     action.type === _reacttable.actions.setScrolledRight &&
     newState.sticky?.isScrolledToRight !== action.value
-  ) {
+  )
     return {
       ...newState,
       sticky: {
@@ -45,34 +43,23 @@ const reducer = (newState, action) => {
         isScrolledToRight: action.value,
       },
     };
-  }
   return newState;
 };
 const useInstance = (instance) => {
-  const { flatHeaders } = instance;
+  let { flatHeaders } = instance;
   flatHeaders.forEach((header) => {
-    if (!header.originalSticky) {
-      header.originalSticky = header.sticky ?? 'none';
-    }
+    if (!header.originalSticky) header.originalSticky = header.sticky ?? 'none';
     header.sticky =
-      header.originalSticky === 'none' ? undefined : header.originalSticky;
+      'none' === header.originalSticky ? void 0 : header.originalSticky;
   });
   let hasLeftStickyColumn = false;
   [...flatHeaders].reverse().forEach((header) => {
-    if (header.sticky === 'left') {
-      hasLeftStickyColumn = true;
-    }
-    if (hasLeftStickyColumn) {
-      header.sticky = 'left';
-    }
+    if ('left' === header.sticky) hasLeftStickyColumn = true;
+    if (hasLeftStickyColumn) header.sticky = 'left';
   });
   let hasRightStickyColumn = false;
   flatHeaders.forEach((header) => {
-    if (header.sticky === 'right') {
-      hasRightStickyColumn = true;
-    }
-    if (hasRightStickyColumn) {
-      header.sticky = 'right';
-    }
+    if ('right' === header.sticky) hasRightStickyColumn = true;
+    if (hasRightStickyColumn) header.sticky = 'right';
   });
 };

package/cjs/core/Table/hooks/useSubRowFiltering.js

@@ -15,24 +15,20 @@ const useSubRowFiltering = (hasAnySubRows) => (hooks) => {
   hooks.useInstance.push(useInstance.bind({}, hasAnySubRows));
 };
 const useInstance = (hasAnySubRows, instance) => {
-  const setInitialSubRows = (rows) => {
+  let setInitialSubRows = (rows) => {
     rows.forEach((row) => {
-      if (!row.initialSubRows) {
-        row.initialSubRows = row.subRows;
-      }
+      if (!row.initialSubRows) row.initialSubRows = row.subRows;
       setInitialSubRows(row.subRows);
     });
   };
   setInitialSubRows(instance.initialRows);
-  const {
+  let {
     filteredRows = instance.filteredRows,
     filteredFlatRows = instance.filteredFlatRows,
     filteredRowsById = instance.filteredRowsById,
   } = _react.useMemo(() => {
-    if (!hasAnySubRows) {
-      return {};
-    }
-    const setSubRows = (rows) => {
+    if (!hasAnySubRows) return {};
+    let setSubRows = (rows) => {
       rows.forEach((row) => {
         row.subRows = row.initialSubRows ?? [];
         setSubRows(row.subRows);
@@ -41,34 +37,28 @@ const useInstance = (hasAnySubRows, instance) => {
     setSubRows(instance.initialRows);
     let currentlyFilteredRows = [...instance.initialRows];
     instance.state.filters.forEach(({ id: columnId, value: filterValue }) => {
-      const column = instance.allColumns.find((c) => c.id === columnId);
-      if (!column) {
-        return;
-      }
-      const filterTypes = {
+      let column = instance.allColumns.find((c) => c.id === columnId);
+      if (!column) return;
+      let filterTypes = {
         ..._defaultFilterFunctions.defaultFilterFunctions,
         ...instance.filterTypes,
       };
-      const filterFn =
-        typeof column.filter === 'function'
+      let filterFn =
+        'function' == typeof column.filter
           ? column.filter
           : filterTypes[column.filter ?? 'text'];
       currentlyFilteredRows = currentlyFilteredRows.filter((row) =>
         handleRowFiltering(row, filterFn, columnId, filterValue),
       );
     });
-    const filteredRows = [];
-    const filteredFlatRows = [];
-    const filteredRowsById = {};
-    const populateRows = (row) => {
-      if (row.depth === 0) {
-        filteredRows.push(row);
-      }
+    let filteredRows = [];
+    let filteredFlatRows = [];
+    let filteredRowsById = {};
+    let populateRows = (row) => {
+      if (0 === row.depth) filteredRows.push(row);
       filteredFlatRows.push(row);
       filteredRowsById[row.id] = row;
-      if (row.subRows.length) {
-        row.subRows.forEach((r) => populateRows(r));
-      }
+      if (row.subRows.length) row.subRows.forEach((r) => populateRows(r));
     };
     currentlyFilteredRows.forEach((row) => populateRows(row));
     return {
@@ -95,15 +85,11 @@ const useInstance = (hasAnySubRows, instance) => {
 const handleRowFiltering = (row, filterFn, columnId, filterValue) => {
   let hasFilteredSubRows = false;
   row.subRows = row.initialSubRows.filter((subRow) => {
-    const result = handleRowFiltering(subRow, filterFn, columnId, filterValue);
-    if (result) {
-      hasFilteredSubRows = true;
-    }
+    let result = handleRowFiltering(subRow, filterFn, columnId, filterValue);
+    if (result) hasFilteredSubRows = true;
     return result;
   });
-  if (hasFilteredSubRows) {
-    return true;
-  }
-  const result = filterFn([row], [columnId], filterValue);
+  if (hasFilteredSubRows) return true;
+  let result = filterFn([row], [columnId], filterValue);
   return !!result.length;
 };

package/cjs/core/Table/hooks/useSubRowSelection.js

@@ -14,15 +14,14 @@ const useSubRowSelection = (hooks) => {
   hooks.useInstance.push(useInstance);
 };
 const useInstance = (instance) => {
-  const selectedFlatRows = _react.useMemo(() => {
-    const selectedFlatRows = [];
-    const setSelectionState = (row, selectedRowIds) => {
+  let selectedFlatRows = _react.useMemo(() => {
+    let selectedFlatRows = [];
+    let setSelectionState = (row, selectedRowIds) => {
       let isSomeSubRowsSelected = false;
       row.initialSubRows.forEach((subRow) => {
         setSelectionState(subRow, selectedRowIds);
-        if (subRow.isSelected || subRow.isSomeSelected) {
+        if (subRow.isSelected || subRow.isSomeSelected)
           isSomeSubRowsSelected = true;
-        }
       });
       if (selectedRowIds[row.id]) {
         row.isSelected = true;

package/cjs/core/Table/utils.js

@@ -26,62 +26,49 @@ _export(exports, {
 const _interop_require_wildcard = require('@swc/helpers/_/_interop_require_wildcard');
 const _react = _interop_require_wildcard._(require('react'));
 const getCellStyle = (column, isTableResizing) => {
-  const style = {};
-  style.flex = `1 1 145px`;
+  let style = {};
+  style.flex = '1 1 145px';
   if (column.width) {
-    const width =
-      typeof column.width === 'string' ? column.width : `${column.width}px`;
+    let width =
+      'string' == typeof column.width ? column.width : `${column.width}px`;
     style.width = width;
-    if (isTableResizing && column.canResize) {
+    if (isTableResizing && column.canResize)
       style.flex = `${Number(column.width)} ${Number(column.width)} ${width}`;
-    } else {
-      style.flex = `0 0 ${width}`;
-    }
-  }
-  if (column.maxWidth) {
-    style.maxWidth = `${column.maxWidth}px`;
-  }
-  if (column.minWidth) {
-    style.minWidth = `${column.minWidth}px`;
+    else style.flex = `0 0 ${width}`;
   }
+  if (column.maxWidth) style.maxWidth = `${column.maxWidth}px`;
+  if (column.minWidth) style.minWidth = `${column.minWidth}px`;
   return style;
 };
 const getStickyStyle = (column, columnList) => {
-  if (!column.sticky) {
-    return {};
-  }
+  if (!column.sticky) return {};
   let left = 0;
-  for (const col of columnList) {
-    if (col.id === column.id) {
-      break;
-    }
+  for (let col of columnList) {
+    if (col.id === column.id) break;
     left += Number(col.width || col.resizeWidth || 0);
   }
   let right = 0;
-  for (const col of [...columnList].reverse()) {
-    if (col.id === column.id) {
-      break;
-    }
+  for (let col of [...columnList].reverse()) {
+    if (col.id === column.id) break;
     right += Number(col.width || col.resizeWidth || 0);
   }
   return {
-    '--iui-table-sticky-left':
-      column.sticky === 'left' ? `${left}px` : undefined,
+    '--iui-table-sticky-left': 'left' === column.sticky ? `${left}px` : void 0,
     '--iui-table-sticky-right':
-      column.sticky === 'right' ? `${right}px` : undefined,
+      'right' === column.sticky ? `${right}px` : void 0,
   };
 };
 const getSubRowStyle = ({ density = 'default', depth = 1 }) => {
   let cellPadding = 16;
   let expanderMargin = 8;
-  if (density === 'condensed') {
+  if ('condensed' === density) {
     cellPadding = 12;
     expanderMargin = 4;
-  } else if (density === 'extra-condensed') {
+  } else if ('extra-condensed' === density) {
     cellPadding = 8;
     expanderMargin = 4;
   }
-  const multiplier = 26 + expanderMargin;
+  let multiplier = 26 + expanderMargin;
   return {
     paddingInlineStart: cellPadding + depth * multiplier,
   };