@itwin/itwinui-react 3.13.4 → 3.14.1

package/DEV-esm/core/Table/hooks/useResizeColumns.js

@@ -1,259 +1,354 @@
 import { actions, makePropGetter, useGetLatest } from 'react-table';
-export const useResizeColumns = (ownerDocument)=>(hooks)=>{
-        hooks.getResizerProps = [
-            defaultGetResizerProps(ownerDocument)
-        ];
-        hooks.stateReducers.push(reducer);
-        hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions);
-    };
-let isTouchEvent = (event)=>'touchstart' === event.type;
-let defaultGetResizerProps = (ownerDocument)=>(props, { instance, header, nextHeader })=>{
-        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)
-                ]);
-            let nextHeaderIdWidths = nextHeader ? getLeafHeaders(nextHeader).map((d)=>[
-                    d.id,
-                    getHeaderWidth(d)
-                ]) : [];
-            let clientX = isTouchEvent(e) ? Math.round(e.touches[0].clientX) : e.clientX;
-            let dispatchMove = (clientXPos)=>dispatch({
-                    type: actions.columnResizing,
-                    clientX: clientXPos
-                });
-            let dispatchEnd = ()=>dispatch({
-                    type: actions.columnDoneResizing
-                });
-            let handlersAndEvents = {
-                mouse: {
-                    moveEvent: 'mousemove',
-                    moveHandler: (e)=>dispatchMove(e.clientX),
-                    upEvent: 'mouseup',
-                    upHandler: ()=>{
-                        ownerDocument.current?.removeEventListener('mousemove', handlersAndEvents.mouse.moveHandler);
-                        ownerDocument.current?.removeEventListener('mouseup', handlersAndEvents.mouse.upHandler);
-                        ownerDocument.current?.removeEventListener('mouseleave', handlersAndEvents.mouse.upHandler);
-                        dispatchEnd();
-                    }
-                },
-                touch: {
-                    moveEvent: 'touchmove',
-                    moveHandler: (e)=>{
-                        if (e.cancelable) {
-                            e.preventDefault();
-                            e.stopPropagation();
-                        }
-                        dispatchMove(e.touches[0].clientX);
-                    },
-                    upEvent: 'touchend',
-                    upHandler: ()=>{
-                        ownerDocument.current?.removeEventListener(handlersAndEvents.touch.moveEvent, handlersAndEvents.touch.moveHandler);
-                        ownerDocument.current?.removeEventListener(handlersAndEvents.touch.upEvent, handlersAndEvents.touch.moveHandler);
-                        dispatchEnd();
-                    }
-                }
-            };
-            let events = isTouchEvent(e) ? handlersAndEvents.touch : handlersAndEvents.mouse;
-            let passiveIfSupported = !!passiveEventSupported() && {
-                passive: false
-            };
-            ownerDocument.current?.addEventListener(events.moveEvent, events.moveHandler, passiveIfSupported);
-            ownerDocument.current?.addEventListener(events.upEvent, events.upHandler, passiveIfSupported);
-            if (!isTouchEvent(e)) ownerDocument.current?.addEventListener('mouseleave', handlersAndEvents.mouse.upHandler, passiveIfSupported);
-            dispatch({
-                type: actions.columnStartResizing,
-                columnId: header.id,
-                columnWidth: getHeaderWidth(header),
-                nextColumnWidth: getHeaderWidth(nextHeader),
-                headerIdWidths,
-                nextHeaderIdWidths,
-                clientX
-            });
-        };
-        return [
-            props,
-            {
-                onClick: (e)=>{
-                    e.stopPropagation();
-                },
-                onMouseDown: (e)=>{
-                    e.persist();
-                    e.preventDefault();
-                    e.stopPropagation();
-                    onResizeStart(e, header);
-                },
-                onTouchStart: (e)=>{
-                    e.persist();
-                    e.preventDefault();
-                    onResizeStart(e, header);
-                },
-                style: {
-                    cursor: 'col-resize'
-                },
-                draggable: false,
-                role: 'separator'
+export const useResizeColumns = (ownerDocument) => (hooks) => {
+  hooks.getResizerProps = [defaultGetResizerProps(ownerDocument)];
+  hooks.stateReducers.push(reducer);
+  hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions);
+};
+let isTouchEvent = (event) => 'touchstart' === event.type;
+let defaultGetResizerProps =
+  (ownerDocument) =>
+  (props, { instance, header, nextHeader }) => {
+    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),
+      ]);
+      let nextHeaderIdWidths = nextHeader
+        ? getLeafHeaders(nextHeader).map((d) => [d.id, getHeaderWidth(d)])
+        : [];
+      let clientX = isTouchEvent(e)
+        ? Math.round(e.touches[0].clientX)
+        : e.clientX;
+      let dispatchMove = (clientXPos) =>
+        dispatch({
+          type: actions.columnResizing,
+          clientX: clientXPos,
+        });
+      let dispatchEnd = () =>
+        dispatch({
+          type: actions.columnDoneResizing,
+        });
+      let handlersAndEvents = {
+        mouse: {
+          moveEvent: 'mousemove',
+          moveHandler: (e) => dispatchMove(e.clientX),
+          upEvent: 'mouseup',
+          upHandler: () => {
+            ownerDocument.current?.removeEventListener(
+              'mousemove',
+              handlersAndEvents.mouse.moveHandler,
+            );
+            ownerDocument.current?.removeEventListener(
+              'mouseup',
+              handlersAndEvents.mouse.upHandler,
+            );
+            ownerDocument.current?.removeEventListener(
+              'mouseleave',
+              handlersAndEvents.mouse.upHandler,
+            );
+            dispatchEnd();
+          },
+        },
+        touch: {
+          moveEvent: 'touchmove',
+          moveHandler: (e) => {
+            if (e.cancelable) {
+              e.preventDefault();
+              e.stopPropagation();
             }
-        ];
+            dispatchMove(e.touches[0].clientX);
+          },
+          upEvent: 'touchend',
+          upHandler: () => {
+            ownerDocument.current?.removeEventListener(
+              handlersAndEvents.touch.moveEvent,
+              handlersAndEvents.touch.moveHandler,
+            );
+            ownerDocument.current?.removeEventListener(
+              handlersAndEvents.touch.upEvent,
+              handlersAndEvents.touch.moveHandler,
+            );
+            dispatchEnd();
+          },
+        },
+      };
+      let events = isTouchEvent(e)
+        ? handlersAndEvents.touch
+        : handlersAndEvents.mouse;
+      let passiveIfSupported = !!passiveEventSupported() && {
+        passive: false,
+      };
+      ownerDocument.current?.addEventListener(
+        events.moveEvent,
+        events.moveHandler,
+        passiveIfSupported,
+      );
+      ownerDocument.current?.addEventListener(
+        events.upEvent,
+        events.upHandler,
+        passiveIfSupported,
+      );
+      if (!isTouchEvent(e))
+        ownerDocument.current?.addEventListener(
+          'mouseleave',
+          handlersAndEvents.mouse.upHandler,
+          passiveIfSupported,
+        );
+      dispatch({
+        type: actions.columnStartResizing,
+        columnId: header.id,
+        columnWidth: getHeaderWidth(header),
+        nextColumnWidth: getHeaderWidth(nextHeader),
+        headerIdWidths,
+        nextHeaderIdWidths,
+        clientX,
+      });
     };
+    return [
+      props,
+      {
+        onClick: (e) => {
+          e.stopPropagation();
+        },
+        onMouseDown: (e) => {
+          e.persist();
+          e.preventDefault();
+          e.stopPropagation();
+          onResizeStart(e, header);
+        },
+        onTouchStart: (e) => {
+          e.persist();
+          e.preventDefault();
+          onResizeStart(e, header);
+        },
+        style: {
+          cursor: 'col-resize',
+        },
+        draggable: false,
+        role: 'separator',
+      },
+    ];
+  };
 useResizeColumns.pluginName = 'useResizeColumns';
-let reducer = (newState, action, previousState, instance)=>{
-    if (action.type === actions.init) return {
-        ...newState,
-        columnResizing: {
-            columnWidths: {}
-        }
+let reducer = (newState, action, previousState, instance) => {
+  if (action.type === actions.init)
+    return {
+      ...newState,
+      columnResizing: {
+        columnWidths: {},
+      },
     };
-    if (action.type === actions.resetResize) return {
-        ...newState,
-        columnResizing: {
-            columnWidths: {}
-        }
+  if (action.type === actions.resetResize)
+    return {
+      ...newState,
+      columnResizing: {
+        columnWidths: {},
+      },
     };
-    if (action.type === actions.columnStartResizing) {
-        let { clientX, columnId, columnWidth, nextColumnWidth, headerIdWidths, nextHeaderIdWidths } = action;
-        return {
-            ...newState,
-            columnResizing: {
-                ...newState.columnResizing,
-                startX: clientX,
-                columnWidth,
-                nextColumnWidth,
-                headerIdWidths,
-                nextHeaderIdWidths,
-                isResizingColumn: columnId
-            }
-        };
-    }
-    if (action.type === actions.columnResizing) {
-        let { clientX } = action;
-        let { startX = 0, columnWidth = 1, nextColumnWidth = 1, headerIdWidths = [], nextHeaderIdWidths = [] } = newState.columnResizing;
-        if (!instance) return newState;
-        let deltaX = clientX - startX;
-        let newColumnWidths = getColumnWidths(headerIdWidths, deltaX / columnWidth);
-        let isTableWidthDecreasing = calculateTableWidth(newColumnWidths, instance.flatHeaders) < instance.tableWidth;
-        let newNextColumnWidths = instance?.columnResizeMode === 'fit' || instance?.columnResizeMode === 'expand' && isTableWidthDecreasing ? getColumnWidths(nextHeaderIdWidths, -deltaX / nextColumnWidth) : {};
-        if (!isNewColumnWidthsValid(newColumnWidths, instance.flatHeaders) || !isNewColumnWidthsValid(newNextColumnWidths, instance.flatHeaders) || !isNewTableWidthValid({
-            ...newColumnWidths,
-            ...newNextColumnWidths
-        }, instance)) return newState;
-        instance?.flatHeaders.forEach((h)=>{
-            if (!h.width) h.width = h.resizeWidth;
-        });
-        return {
-            ...newState,
-            columnResizing: {
-                ...newState.columnResizing,
-                columnWidths: {
-                    ...newState.columnResizing.columnWidths,
-                    ...newColumnWidths,
-                    ...newNextColumnWidths
-                }
-            }
-        };
-    }
-    if (action.type === actions.columnDoneResizing) return {
-        ...newState,
-        columnResizing: {
-            ...newState.columnResizing,
-            startX: void 0,
-            isResizingColumn: void 0
-        }
+  if (action.type === actions.columnStartResizing) {
+    let {
+      clientX,
+      columnId,
+      columnWidth,
+      nextColumnWidth,
+      headerIdWidths,
+      nextHeaderIdWidths,
+    } = action;
+    return {
+      ...newState,
+      columnResizing: {
+        ...newState.columnResizing,
+        startX: clientX,
+        columnWidth,
+        nextColumnWidth,
+        headerIdWidths,
+        nextHeaderIdWidths,
+        isResizingColumn: columnId,
+      },
     };
-    return newState;
-};
-let getColumnWidths = (headerIdWidths, deltaPercentage)=>{
-    let columnWidths = {};
-    headerIdWidths.forEach(([headerId, headerWidth])=>{
-        columnWidths[headerId] = Math.max(headerWidth + headerWidth * deltaPercentage, 0);
+  }
+  if (action.type === actions.columnResizing) {
+    let { clientX } = action;
+    let {
+      startX = 0,
+      columnWidth = 1,
+      nextColumnWidth = 1,
+      headerIdWidths = [],
+      nextHeaderIdWidths = [],
+    } = newState.columnResizing;
+    if (!instance) return newState;
+    let deltaX = clientX - startX;
+    let newColumnWidths = getColumnWidths(headerIdWidths, deltaX / columnWidth);
+    let isTableWidthDecreasing =
+      calculateTableWidth(newColumnWidths, instance.flatHeaders) <
+      instance.tableWidth;
+    let newNextColumnWidths =
+      instance?.columnResizeMode === 'fit' ||
+      (instance?.columnResizeMode === 'expand' && isTableWidthDecreasing)
+        ? getColumnWidths(nextHeaderIdWidths, -deltaX / nextColumnWidth)
+        : {};
+    if (
+      !isNewColumnWidthsValid(newColumnWidths, instance.flatHeaders) ||
+      !isNewColumnWidthsValid(newNextColumnWidths, instance.flatHeaders) ||
+      !isNewTableWidthValid(
+        {
+          ...newColumnWidths,
+          ...newNextColumnWidths,
+        },
+        instance,
+      )
+    )
+      return newState;
+    instance?.flatHeaders.forEach((h) => {
+      if (!h.width) h.width = h.resizeWidth;
     });
-    return columnWidths;
+    return {
+      ...newState,
+      columnResizing: {
+        ...newState.columnResizing,
+        columnWidths: {
+          ...newState.columnResizing.columnWidths,
+          ...newColumnWidths,
+          ...newNextColumnWidths,
+        },
+      },
+    };
+  }
+  if (action.type === actions.columnDoneResizing)
+    return {
+      ...newState,
+      columnResizing: {
+        ...newState.columnResizing,
+        startX: void 0,
+        isResizingColumn: void 0,
+      },
+    };
+  return newState;
 };
-let isNewColumnWidthsValid = (columnWidths, headers)=>{
-    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;
+let getColumnWidths = (headerIdWidths, deltaPercentage) => {
+  let columnWidths = {};
+  headerIdWidths.forEach(([headerId, headerWidth]) => {
+    columnWidths[headerId] = Math.max(
+      headerWidth + headerWidth * deltaPercentage,
+      0,
+    );
+  });
+  return columnWidths;
 };
-let isNewTableWidthValid = (columnWidths, instance)=>{
-    if ('fit' === instance.columnResizeMode) return true;
-    let newTableWidth = 0;
-    for (let header of instance.flatHeaders)newTableWidth += columnWidths[header.id] ? columnWidths[header.id] : getHeaderWidth(header);
-    if (Math.round(newTableWidth) < instance.tableWidth) return false;
-    return true;
+let isNewColumnWidthsValid = (columnWidths, headers) => {
+  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;
 };
-let useInstanceBeforeDimensions = (instance)=>{
-    let { flatHeaders, getHooks, state: { columnResizing }, columnResizeMode } = instance;
-    let getInstance = useGetLatest(instance);
-    flatHeaders.forEach((header, index)=>{
-        let resizeWidth = columnResizing.columnWidths[header.id];
-        header.width = resizeWidth || header.width || header.originalWidth;
-        header.isResizing = columnResizing.isResizingColumn === header.id;
-        let headerToResize = header.disableResizing && 'fit' === columnResizeMode ? getPreviousResizableHeader(header, instance) : header;
-        let nextResizableHeader = 'expand' === columnResizeMode && index === flatHeaders.length - 1 ? getPreviousResizableHeader(header, instance) : getNextResizableHeader(header, instance);
-        header.canResize = 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;
-        header.getResizerProps = makePropGetter(getHooks().getResizerProps, {
-            instance: getInstance(),
-            header: headerToResize,
-            nextHeader: nextResizableHeader
-        });
+let isNewTableWidthValid = (columnWidths, instance) => {
+  if ('fit' === instance.columnResizeMode) return true;
+  let newTableWidth = 0;
+  for (let header of instance.flatHeaders)
+    newTableWidth += columnWidths[header.id]
+      ? columnWidths[header.id]
+      : getHeaderWidth(header);
+  if (Math.round(newTableWidth) < instance.tableWidth) return false;
+  return true;
+};
+let useInstanceBeforeDimensions = (instance) => {
+  let {
+    flatHeaders,
+    getHooks,
+    state: { columnResizing },
+    columnResizeMode,
+  } = instance;
+  let getInstance = useGetLatest(instance);
+  flatHeaders.forEach((header, index) => {
+    let resizeWidth = columnResizing.columnWidths[header.id];
+    header.width = resizeWidth || header.width || header.originalWidth;
+    header.isResizing = columnResizing.isResizingColumn === header.id;
+    let headerToResize =
+      header.disableResizing && 'fit' === columnResizeMode
+        ? getPreviousResizableHeader(header, instance)
+        : header;
+    let nextResizableHeader =
+      'expand' === columnResizeMode && index === flatHeaders.length - 1
+        ? getPreviousResizableHeader(header, instance)
+        : getNextResizableHeader(header, instance);
+    header.canResize =
+      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;
+    header.getResizerProps = makePropGetter(getHooks().getResizerProps, {
+      instance: getInstance(),
+      header: headerToResize,
+      nextHeader: nextResizableHeader,
     });
+  });
 };
-let getPreviousResizableHeader = (headerColumn, instance)=>{
-    let headersList = (headerColumn.parent?.columns || instance.flatHeaders).filter(({ isVisible })=>isVisible);
-    let headerIndex = headersList.findIndex((h)=>h.id === headerColumn.id);
-    return [
-        ...headersList
-    ].slice(0, headerIndex).reverse().find((h)=>!h.disableResizing);
+let getPreviousResizableHeader = (headerColumn, instance) => {
+  let headersList = (
+    headerColumn.parent?.columns || instance.flatHeaders
+  ).filter(({ isVisible }) => isVisible);
+  let headerIndex = headersList.findIndex((h) => h.id === headerColumn.id);
+  return [...headersList]
+    .slice(0, headerIndex)
+    .reverse()
+    .find((h) => !h.disableResizing);
 };
-let getNextResizableHeader = (headerColumn, instance)=>{
-    let headersList = (headerColumn.parent?.columns || instance.flatHeaders).filter(({ isVisible })=>isVisible);
-    let headerIndex = headersList.findIndex((h)=>h.id === headerColumn.id);
-    return [
-        ...headersList
-    ].slice(headerIndex + 1).find((h)=>!h.disableResizing);
+let getNextResizableHeader = (headerColumn, instance) => {
+  let headersList = (
+    headerColumn.parent?.columns || instance.flatHeaders
+  ).filter(({ isVisible }) => isVisible);
+  let headerIndex = headersList.findIndex((h) => h.id === headerColumn.id);
+  return [...headersList]
+    .slice(headerIndex + 1)
+    .find((h) => !h.disableResizing);
 };
 function getLeafHeaders(header) {
-    let leafHeaders = [];
-    let recurseHeader = (header)=>{
-        if (header.columns && header.columns.length) header.columns.map(recurseHeader);
-        leafHeaders.push(header);
-    };
-    recurseHeader(header);
-    return leafHeaders;
+  let leafHeaders = [];
+  let recurseHeader = (header) => {
+    if (header.columns && header.columns.length)
+      header.columns.map(recurseHeader);
+    leafHeaders.push(header);
+  };
+  recurseHeader(header);
+  return leafHeaders;
 }
-let getHeaderWidth = (header)=>{
-    if (!header) return 0;
-    return 'string' == typeof header.width && Number.isNaN(Number(header.width)) ? Number(header.resizeWidth || 0) : Number(header.width || header.resizeWidth || 0);
+let getHeaderWidth = (header) => {
+  if (!header) return 0;
+  return 'string' == typeof header.width && Number.isNaN(Number(header.width))
+    ? Number(header.resizeWidth || 0)
+    : Number(header.width || header.resizeWidth || 0);
 };
-let calculateTableWidth = (columnWidths, headers)=>{
-    let newTableWidth = 0;
-    for (let header of headers)newTableWidth += columnWidths[header.id] ? columnWidths[header.id] : getHeaderWidth(header);
-    return newTableWidth;
+let calculateTableWidth = (columnWidths, headers) => {
+  let newTableWidth = 0;
+  for (let header of headers)
+    newTableWidth += columnWidths[header.id]
+      ? columnWidths[header.id]
+      : getHeaderWidth(header);
+  return newTableWidth;
 };
 let passiveSupported = null;
-let passiveEventSupported = ()=>{
-    if (null != passiveSupported) return passiveSupported;
-    try {
-        let options = {
-            once: true,
-            get passive () {
-                passiveSupported = true;
-                return false;
-            }
-        };
-        window.addEventListener('test', ()=>{}, options);
-    } catch  {
-        passiveSupported = false;
-    }
-    return passiveSupported;
+let passiveEventSupported = () => {
+  if (null != passiveSupported) return passiveSupported;
+  try {
+    let options = {
+      once: true,
+      get passive() {
+        passiveSupported = true;
+        return false;
+      },
+    };
+    window.addEventListener('test', () => {}, options);
+  } catch {
+    passiveSupported = false;
+  }
+  return passiveSupported;
 };

package/DEV-esm/core/Table/hooks/useScrollToRow.js

@@ -1,30 +1,34 @@
 import * as React from 'react';
-export function useScrollToRow({ data, enableVirtualization, page, paginatorRenderer, scrollToRow }) {
-    let rowRefs = React.useRef({});
-    let pageRef = React.useRef(page);
-    pageRef.current = page;
-    let dataRef = React.useRef(data);
-    dataRef.current = data;
-    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 || null == scrollToIndex || scrollToIndex < 0) return;
-        rowRefs.current[pageRef.current[scrollToIndex]?.id]?.scrollIntoView();
-    }, [
-        enableVirtualization,
-        scrollToIndex
-    ]);
-    let tableRowRef = React.useCallback((row)=>(element)=>{
-            rowRefs.current[row.id] = element;
-        }, []);
-    return {
-        scrollToIndex,
-        tableRowRef
-    };
+export function useScrollToRow({
+  data,
+  enableVirtualization,
+  page,
+  paginatorRenderer,
+  scrollToRow,
+}) {
+  let rowRefs = React.useRef({});
+  let pageRef = React.useRef(page);
+  pageRef.current = page;
+  let dataRef = React.useRef(data);
+  dataRef.current = data;
+  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 || null == scrollToIndex || scrollToIndex < 0)
+      return;
+    rowRefs.current[pageRef.current[scrollToIndex]?.id]?.scrollIntoView();
+  }, [enableVirtualization, scrollToIndex]);
+  let tableRowRef = React.useCallback(
+    (row) => (element) => {
+      rowRefs.current[row.id] = element;
+    },
+    [],
+  );
+  return {
+    scrollToIndex,
+    tableRowRef,
+  };
 }