@itwin/itwinui-react 3.12.2 → 3.13.0

package/cjs/core/Table/filters/defaultFilterFunctions.js

@@ -9,119 +9,110 @@ Object.defineProperty(exports, 'defaultFilterFunctions', {
   },
 });
 const text = (rows, ids, filterValue) => {
-  rows = rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
+  rows = rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
       return String(rowValue)
         .toLowerCase()
         .includes(String(filterValue).toLowerCase());
-    });
-  });
+    }),
+  );
   return rows;
 };
 text.autoRemove = (val) => !val;
-const exactText = (rows, ids, filterValue) => {
-  return rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
-      return rowValue !== undefined
-        ? String(rowValue).toLowerCase() === String(filterValue).toLowerCase()
-        : true;
-    });
-  });
-};
+const exactText = (rows, ids, filterValue) =>
+  rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
+      return (
+        void 0 === rowValue ||
+        String(rowValue).toLowerCase() === String(filterValue).toLowerCase()
+      );
+    }),
+  );
 exactText.autoRemove = (val) => !val;
-const exactTextCase = (rows, ids, filterValue) => {
-  return rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
-      return rowValue !== undefined
-        ? String(rowValue) === String(filterValue)
-        : true;
-    });
-  });
-};
+const exactTextCase = (rows, ids, filterValue) =>
+  rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
+      return void 0 === rowValue || String(rowValue) === String(filterValue);
+    }),
+  );
 exactTextCase.autoRemove = (val) => !val;
-const includes = (rows, ids, filterValue) => {
-  return rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
+const includes = (rows, ids, filterValue) =>
+  rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
       return rowValue.includes(filterValue);
-    });
-  });
-};
+    }),
+  );
 includes.autoRemove = (val) => !val || !val.length;
-const includesAll = (rows, ids, filterValue) => {
-  return rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
+const includesAll = (rows, ids, filterValue) =>
+  rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
       return (
         rowValue &&
         rowValue.length &&
         filterValue.every((val) => rowValue.includes(val))
       );
-    });
-  });
-};
+    }),
+  );
 includesAll.autoRemove = (val) => !val || !val.length;
-const includesSome = (rows, ids, filterValue) => {
-  return rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
+const includesSome = (rows, ids, filterValue) =>
+  rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
       return (
         rowValue &&
         rowValue.length &&
         filterValue.some((val) => rowValue.includes(val))
       );
-    });
-  });
-};
+    }),
+  );
 includesSome.autoRemove = (val) => !val || !val.length;
-const includesValue = (rows, ids, filterValue) => {
-  return rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
+const includesValue = (rows, ids, filterValue) =>
+  rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
       return filterValue.includes(rowValue);
-    });
-  });
-};
+    }),
+  );
 includesValue.autoRemove = (val) => !val || !val.length;
-const exact = (rows, ids, filterValue) => {
-  return rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
+const exact = (rows, ids, filterValue) =>
+  rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
       return rowValue === filterValue;
-    });
-  });
-};
-exact.autoRemove = (val) => typeof val === 'undefined';
-const equals = (rows, ids, filterValue) => {
-  return rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
+    }),
+  );
+exact.autoRemove = (val) => void 0 === val;
+const equals = (rows, ids, filterValue) =>
+  rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
       return rowValue == filterValue;
-    });
-  });
-};
-equals.autoRemove = (val) => val == null;
+    }),
+  );
+equals.autoRemove = (val) => null == val;
 const between = (rows, ids, filterValue) => {
   let [min, max] = filterValue || [];
-  min = typeof min === 'number' ? min : -Infinity;
-  max = typeof max === 'number' ? max : Infinity;
+  min = 'number' == typeof min ? min : -1 / 0;
+  max = 'number' == typeof max ? max : 1 / 0;
   if (min > max) {
-    const temp = min;
+    let temp = min;
     min = max;
     max = temp;
   }
-  return rows.filter((row) => {
-    return ids.some((id) => {
-      const rowValue = row.values[id];
+  return rows.filter((row) =>
+    ids.some((id) => {
+      let rowValue = row.values[id];
       return rowValue >= min && rowValue <= max;
-    });
-  });
+    }),
+  );
 };
 between.autoRemove = (val) =>
-  !val || (typeof val[0] !== 'number' && typeof val[1] !== 'number');
+  !val || ('number' != typeof val[0] && 'number' != typeof val[1]);
 const defaultFilterFunctions = {
   text,
   exactText,

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

@@ -22,63 +22,57 @@ const useColumnDragAndDrop = (isEnabled) => (hooks) => {
 const defaultGetDragAndDropProps =
   (isEnabled) =>
   (props, { instance, header }) => {
-    if (!isEnabled || header.disableReordering) {
-      return props;
-    }
-    const onDragStart = () => {
+    if (!isEnabled || header.disableReordering) return props;
+    let onDragStart = () => {
       instance.dispatch({
         type: REORDER_ACTIONS.columnDragStart,
         columnIndex: instance.flatHeaders.indexOf(header),
       });
     };
-    const setOnDragColumnStyle = (event, position) => {
-      const columnElement = event.currentTarget;
+    let setOnDragColumnStyle = (event, position) => {
+      let columnElement = event.currentTarget;
       columnElement.classList.remove(
         _styles.styles['iui-table-reorder-column-right'],
       );
       columnElement.classList.remove(
         _styles.styles['iui-table-reorder-column-left'],
       );
-      if (position === 'left') {
+      if ('left' === position)
         columnElement.classList.add(
           _styles.styles['iui-table-reorder-column-left'],
         );
-      } else if (position === 'right') {
+      else if ('right' === position)
         columnElement.classList.add(
           _styles.styles['iui-table-reorder-column-right'],
         );
-      }
     };
-    const reorderColumns = (tableColumns, srcIndex, dstIndex) => {
-      const newTableColumns = [...tableColumns];
-      const [removed] = newTableColumns.splice(srcIndex, 1);
+    let reorderColumns = (tableColumns, srcIndex, dstIndex) => {
+      let newTableColumns = [...tableColumns];
+      let [removed] = newTableColumns.splice(srcIndex, 1);
       newTableColumns.splice(dstIndex, 0, removed);
       return newTableColumns;
     };
-    const onDragOver = (event) => {
+    let onDragOver = (event) => {
       event.preventDefault();
-      const headerIndex = instance.flatHeaders.indexOf(header);
-      if (instance.state.columnReorderStartIndex !== headerIndex) {
+      let headerIndex = instance.flatHeaders.indexOf(header);
+      if (instance.state.columnReorderStartIndex !== headerIndex)
         setOnDragColumnStyle(
           event,
           instance.state.columnReorderStartIndex > headerIndex
             ? 'left'
             : 'right',
         );
-      }
     };
-    const onDragLeave = (event) => {
+    let onDragLeave = (event) => {
       setOnDragColumnStyle(event);
     };
-    const onDrop = (event) => {
+    let onDrop = (event) => {
       event.preventDefault();
       setOnDragColumnStyle(event);
-      const columnIds = instance.allColumns.map((x) => x.id);
-      const srcIndex = instance.state.columnReorderStartIndex;
-      const dstIndex = columnIds.findIndex((x) => x === header.id);
-      if (srcIndex === dstIndex || srcIndex === -1 || dstIndex === -1) {
-        return;
-      }
+      let columnIds = instance.allColumns.map((x) => x.id);
+      let srcIndex = instance.state.columnReorderStartIndex;
+      let dstIndex = columnIds.findIndex((x) => x === header.id);
+      if (srcIndex === dstIndex || -1 === srcIndex || -1 === dstIndex) return;
       instance.setColumnOrder(reorderColumns(columnIds, srcIndex, dstIndex));
       instance.dispatch({
         type: REORDER_ACTIONS.columnDragEnd,
@@ -118,8 +112,8 @@ const reducer = (newState, action) => {
   }
 };
 const useInstance = (instance) => {
-  const { flatHeaders, getHooks } = instance;
-  const getInstance = (0, _reacttable.useGetLatest)(instance);
+  let { flatHeaders, getHooks } = instance;
+  let getInstance = (0, _reacttable.useGetLatest)(instance);
   flatHeaders.forEach((header) => {
     header.getDragAndDropProps = (0, _reacttable.makePropGetter)(
       getHooks().getDragAndDropProps,

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

@@ -13,17 +13,13 @@ const _react = _interop_require_wildcard._(require('react'));
 const _index = require('../columns/index.js');
 const useExpanderCell =
   (subComponent, expanderCell, isRowDisabled) => (hooks) => {
-    if (!subComponent) {
-      return;
-    }
+    if (!subComponent) return;
     hooks.allColumns.push((columns) => {
-      const hasExpanderColumn = columns.find(
+      let hasExpanderColumn = columns.find(
         (c) => c.id === _index.EXPANDER_CELL_ID,
       );
-      if (hasExpanderColumn) {
-        return columns;
-      }
-      const expanderColumn = (0, _index.ExpanderColumn)({
+      if (hasExpanderColumn) return columns;
+      let expanderColumn = (0, _index.ExpanderColumn)({
         subComponent,
         isDisabled: isRowDisabled,
       });

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

@@ -14,37 +14,33 @@ const useResizeColumns = (ownerDocument) => (hooks) => {
   hooks.stateReducers.push(reducer);
   hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions);
 };
-const isTouchEvent = (event) => {
-  return event.type === 'touchstart';
-};
+const isTouchEvent = (event) => 'touchstart' === event.type;
 const defaultGetResizerProps =
   (ownerDocument) =>
   (props, { instance, header, nextHeader }) => {
-    const { dispatch } = instance;
-    const onResizeStart = (e, header) => {
-      if (isTouchEvent(e) && e.touches && e.touches.length > 1) {
-        return;
-      }
-      const headerIdWidths = getLeafHeaders(header).map((d) => [
+    let { dispatch } = instance;
+    let onResizeStart = (e, header) => {
+      if (isTouchEvent(e) && e.touches && e.touches.length > 1) return;
+      let headerIdWidths = getLeafHeaders(header).map((d) => [
         d.id,
         getHeaderWidth(d),
       ]);
-      const nextHeaderIdWidths = nextHeader
+      let nextHeaderIdWidths = nextHeader
         ? getLeafHeaders(nextHeader).map((d) => [d.id, getHeaderWidth(d)])
         : [];
-      const clientX = isTouchEvent(e)
+      let clientX = isTouchEvent(e)
         ? Math.round(e.touches[0].clientX)
         : e.clientX;
-      const dispatchMove = (clientXPos) =>
+      let dispatchMove = (clientXPos) =>
         dispatch({
           type: _reacttable.actions.columnResizing,
           clientX: clientXPos,
         });
-      const dispatchEnd = () =>
+      let dispatchEnd = () =>
         dispatch({
           type: _reacttable.actions.columnDoneResizing,
         });
-      const handlersAndEvents = {
+      let handlersAndEvents = {
         mouse: {
           moveEvent: 'mousemove',
           moveHandler: (e) => dispatchMove(e.clientX),
@@ -88,14 +84,12 @@ const defaultGetResizerProps =
           },
         },
       };
-      const events = isTouchEvent(e)
+      let events = isTouchEvent(e)
         ? handlersAndEvents.touch
         : handlersAndEvents.mouse;
-      const passiveIfSupported = passiveEventSupported()
-        ? {
-            passive: false,
-          }
-        : false;
+      let passiveIfSupported = !!passiveEventSupported() && {
+        passive: false,
+      };
       ownerDocument.current?.addEventListener(
         events.moveEvent,
         events.moveHandler,
@@ -106,13 +100,12 @@ const defaultGetResizerProps =
         events.upHandler,
         passiveIfSupported,
       );
-      if (!isTouchEvent(e)) {
+      if (!isTouchEvent(e))
         ownerDocument.current?.addEventListener(
           'mouseleave',
           handlersAndEvents.mouse.upHandler,
           passiveIfSupported,
         );
-      }
       dispatch({
         type: _reacttable.actions.columnStartResizing,
         columnId: header.id,
@@ -150,24 +143,22 @@ const defaultGetResizerProps =
   };
 useResizeColumns.pluginName = 'useResizeColumns';
 const reducer = (newState, action, previousState, instance) => {
-  if (action.type === _reacttable.actions.init) {
+  if (action.type === _reacttable.actions.init)
     return {
       ...newState,
       columnResizing: {
         columnWidths: {},
       },
     };
-  }
-  if (action.type === _reacttable.actions.resetResize) {
+  if (action.type === _reacttable.actions.resetResize)
     return {
       ...newState,
       columnResizing: {
         columnWidths: {},
       },
     };
-  }
   if (action.type === _reacttable.actions.columnStartResizing) {
-    const {
+    let {
       clientX,
       columnId,
       columnWidth,
@@ -189,26 +180,21 @@ const reducer = (newState, action, previousState, instance) => {
     };
   }
   if (action.type === _reacttable.actions.columnResizing) {
-    const { clientX } = action;
-    const {
+    let { clientX } = action;
+    let {
       startX = 0,
       columnWidth = 1,
       nextColumnWidth = 1,
       headerIdWidths = [],
       nextHeaderIdWidths = [],
     } = newState.columnResizing;
-    if (!instance) {
-      return newState;
-    }
-    const deltaX = clientX - startX;
-    const newColumnWidths = getColumnWidths(
-      headerIdWidths,
-      deltaX / columnWidth,
-    );
-    const isTableWidthDecreasing =
+    if (!instance) return newState;
+    let deltaX = clientX - startX;
+    let newColumnWidths = getColumnWidths(headerIdWidths, deltaX / columnWidth);
+    let isTableWidthDecreasing =
       calculateTableWidth(newColumnWidths, instance.flatHeaders) <
       instance.tableWidth;
-    const newNextColumnWidths =
+    let newNextColumnWidths =
       instance?.columnResizeMode === 'fit' ||
       (instance?.columnResizeMode === 'expand' && isTableWidthDecreasing)
         ? getColumnWidths(nextHeaderIdWidths, -deltaX / nextColumnWidth)
@@ -223,13 +209,10 @@ const reducer = (newState, action, previousState, instance) => {
         },
         instance,
       )
-    ) {
+    )
       return newState;
-    }
     instance?.flatHeaders.forEach((h) => {
-      if (!h.width) {
-        h.width = h.resizeWidth;
-      }
+      if (!h.width) h.width = h.resizeWidth;
     });
     return {
       ...newState,
@@ -243,20 +226,19 @@ const reducer = (newState, action, previousState, instance) => {
       },
     };
   }
-  if (action.type === _reacttable.actions.columnDoneResizing) {
+  if (action.type === _reacttable.actions.columnDoneResizing)
     return {
       ...newState,
       columnResizing: {
         ...newState.columnResizing,
-        startX: undefined,
-        isResizingColumn: undefined,
+        startX: void 0,
+        isResizingColumn: void 0,
       },
     };
-  }
   return newState;
 };
 const getColumnWidths = (headerIdWidths, deltaPercentage) => {
-  const columnWidths = {};
+  let columnWidths = {};
   headerIdWidths.forEach(([headerId, headerWidth]) => {
     columnWidths[headerId] = Math.max(
       headerWidth + headerWidth * deltaPercentage,
@@ -266,66 +248,53 @@ const getColumnWidths = (headerIdWidths, deltaPercentage) => {
   return columnWidths;
 };
 const isNewColumnWidthsValid = (columnWidths, headers) => {
-  if (Object.values(columnWidths).some((width) => width <= 1)) {
-    return false;
-  }
-  for (const [headerId, width] of Object.entries(columnWidths)) {
-    const header = headers?.find((h) => h.id === headerId);
-    if (!header) {
-      continue;
-    }
-    const minWidth = header.minWidth || 0;
-    const maxWidth = header.maxWidth || Infinity;
-    if (width < minWidth || width > maxWidth) {
-      return false;
-    }
+  if (Object.values(columnWidths).some((width) => width <= 1)) return false;
+  for (let [headerId, width] of Object.entries(columnWidths)) {
+    let header = headers?.find((h) => h.id === headerId);
+    if (!header) continue;
+    let minWidth = header.minWidth || 0;
+    let maxWidth = header.maxWidth || 1 / 0;
+    if (width < minWidth || width > maxWidth) return false;
   }
   return true;
 };
 const isNewTableWidthValid = (columnWidths, instance) => {
-  if (instance.columnResizeMode === 'fit') {
-    return true;
-  }
+  if ('fit' === instance.columnResizeMode) return true;
   let newTableWidth = 0;
-  for (const header of instance.flatHeaders) {
+  for (let header of instance.flatHeaders)
     newTableWidth += columnWidths[header.id]
       ? columnWidths[header.id]
       : getHeaderWidth(header);
-  }
-  if (Math.round(newTableWidth) < instance.tableWidth) {
-    return false;
-  }
+  if (Math.round(newTableWidth) < instance.tableWidth) return false;
   return true;
 };
 const useInstanceBeforeDimensions = (instance) => {
-  const {
+  let {
     flatHeaders,
     getHooks,
     state: { columnResizing },
     columnResizeMode,
   } = instance;
-  const getInstance = (0, _reacttable.useGetLatest)(instance);
+  let getInstance = (0, _reacttable.useGetLatest)(instance);
   flatHeaders.forEach((header, index) => {
-    const resizeWidth = columnResizing.columnWidths[header.id];
+    let resizeWidth = columnResizing.columnWidths[header.id];
     header.width = resizeWidth || header.width || header.originalWidth;
     header.isResizing = columnResizing.isResizingColumn === header.id;
-    const headerToResize =
-      header.disableResizing && columnResizeMode === 'fit'
+    let headerToResize =
+      header.disableResizing && 'fit' === columnResizeMode
         ? getPreviousResizableHeader(header, instance)
         : header;
-    const nextResizableHeader =
-      columnResizeMode === 'expand' && index === flatHeaders.length - 1
+    let nextResizableHeader =
+      'expand' === columnResizeMode && index === flatHeaders.length - 1
         ? getPreviousResizableHeader(header, instance)
         : getNextResizableHeader(header, instance);
     header.canResize =
-      header.disableResizing != null ? !header.disableResizing : true;
-    if (columnResizeMode === 'fit') {
+      null == header.disableResizing || !header.disableResizing;
+    if ('fit' === columnResizeMode)
       header.isResizerVisible =
         (header.canResize && !!nextResizableHeader) ||
         (headerToResize && !!instance.flatHeaders[index + 1]?.canResize);
-    } else {
-      header.isResizerVisible = header.canResize && !!headerToResize;
-    }
+    else header.isResizerVisible = header.canResize && !!headerToResize;
     header.getResizerProps = (0, _reacttable.makePropGetter)(
       getHooks().getResizerProps,
       {
@@ -337,59 +306,53 @@ const useInstanceBeforeDimensions = (instance) => {
   });
 };
 const getPreviousResizableHeader = (headerColumn, instance) => {
-  const headersList = (
+  let headersList = (
     headerColumn.parent?.columns || instance.flatHeaders
   ).filter(({ isVisible }) => isVisible);
-  const headerIndex = headersList.findIndex((h) => h.id === headerColumn.id);
+  let headerIndex = headersList.findIndex((h) => h.id === headerColumn.id);
   return [...headersList]
     .slice(0, headerIndex)
     .reverse()
     .find((h) => !h.disableResizing);
 };
 const getNextResizableHeader = (headerColumn, instance) => {
-  const headersList = (
+  let headersList = (
     headerColumn.parent?.columns || instance.flatHeaders
   ).filter(({ isVisible }) => isVisible);
-  const headerIndex = headersList.findIndex((h) => h.id === headerColumn.id);
+  let headerIndex = headersList.findIndex((h) => h.id === headerColumn.id);
   return [...headersList]
     .slice(headerIndex + 1)
     .find((h) => !h.disableResizing);
 };
 function getLeafHeaders(header) {
-  const leafHeaders = [];
-  const recurseHeader = (header) => {
-    if (header.columns && header.columns.length) {
+  let leafHeaders = [];
+  let recurseHeader = (header) => {
+    if (header.columns && header.columns.length)
       header.columns.map(recurseHeader);
-    }
     leafHeaders.push(header);
   };
   recurseHeader(header);
   return leafHeaders;
 }
 const getHeaderWidth = (header) => {
-  if (!header) {
-    return 0;
-  }
-  return typeof header.width === 'string' && Number.isNaN(Number(header.width))
+  if (!header) return 0;
+  return 'string' == typeof header.width && Number.isNaN(Number(header.width))
     ? Number(header.resizeWidth || 0)
     : Number(header.width || header.resizeWidth || 0);
 };
 const calculateTableWidth = (columnWidths, headers) => {
   let newTableWidth = 0;
-  for (const header of headers) {
+  for (let header of headers)
     newTableWidth += columnWidths[header.id]
       ? columnWidths[header.id]
       : getHeaderWidth(header);
-  }
   return newTableWidth;
 };
 let passiveSupported = null;
 const passiveEventSupported = () => {
-  if (passiveSupported != null) {
-    return passiveSupported;
-  }
+  if (null != passiveSupported) return passiveSupported;
   try {
-    const options = {
+    let options = {
       once: true,
       get passive() {
         passiveSupported = true;