@tanstack/table-core 8.9.7 → 8.9.8

package/src/features/Pinning.ts

@@ -82,206 +82,186 @@ export const Pinning: TableFeature = {
   createColumn: <TData extends RowData, TValue>(
     column: Column<TData, TValue>,
     table: Table<TData>
-  ): ColumnPinningColumn => {
-    return {
-      pin: position => {
-        const columnIds = column
-          .getLeafColumns()
-          .map(d => d.id)
-          .filter(Boolean) as string[]
-
-        table.setColumnPinning(old => {
-          if (position === 'right') {
-            return {
-              left: (old?.left ?? []).filter(d => !columnIds?.includes(d)),
-              right: [
-                ...(old?.right ?? []).filter(d => !columnIds?.includes(d)),
-                ...columnIds,
-              ],
-            }
-          }
-
-          if (position === 'left') {
-            return {
-              left: [
-                ...(old?.left ?? []).filter(d => !columnIds?.includes(d)),
-                ...columnIds,
-              ],
-              right: (old?.right ?? []).filter(d => !columnIds?.includes(d)),
-            }
+  ): void => {
+    column.pin = position => {
+      const columnIds = column
+        .getLeafColumns()
+        .map(d => d.id)
+        .filter(Boolean) as string[]
+
+      table.setColumnPinning(old => {
+        if (position === 'right') {
+          return {
+            left: (old?.left ?? []).filter(d => !columnIds?.includes(d)),
+            right: [
+              ...(old?.right ?? []).filter(d => !columnIds?.includes(d)),
+              ...columnIds,
+            ],
           }
+        }
 
+        if (position === 'left') {
           return {
-            left: (old?.left ?? []).filter(d => !columnIds?.includes(d)),
+            left: [
+              ...(old?.left ?? []).filter(d => !columnIds?.includes(d)),
+              ...columnIds,
+            ],
             right: (old?.right ?? []).filter(d => !columnIds?.includes(d)),
           }
-        })
-      },
+        }
 
-      getCanPin: () => {
-        const leafColumns = column.getLeafColumns()
+        return {
+          left: (old?.left ?? []).filter(d => !columnIds?.includes(d)),
+          right: (old?.right ?? []).filter(d => !columnIds?.includes(d)),
+        }
+      })
+    }
 
-        return leafColumns.some(
-          d =>
-            (d.columnDef.enablePinning ?? true) &&
-            (table.options.enablePinning ?? true)
-        )
-      },
+    column.getCanPin = () => {
+      const leafColumns = column.getLeafColumns()
 
-      getIsPinned: () => {
-        const leafColumnIds = column.getLeafColumns().map(d => d.id)
+      return leafColumns.some(
+        d =>
+          (d.columnDef.enablePinning ?? true) &&
+          (table.options.enablePinning ?? true)
+      )
+    }
 
-        const { left, right } = table.getState().columnPinning
+    column.getIsPinned = () => {
+      const leafColumnIds = column.getLeafColumns().map(d => d.id)
 
-        const isLeft = leafColumnIds.some(d => left?.includes(d))
-        const isRight = leafColumnIds.some(d => right?.includes(d))
+      const { left, right } = table.getState().columnPinning
 
-        return isLeft ? 'left' : isRight ? 'right' : false
-      },
+      const isLeft = leafColumnIds.some(d => left?.includes(d))
+      const isRight = leafColumnIds.some(d => right?.includes(d))
 
-      getPinnedIndex: () => {
-        const position = column.getIsPinned()
+      return isLeft ? 'left' : isRight ? 'right' : false
+    }
 
-        return position
-          ? table.getState().columnPinning?.[position]?.indexOf(column.id) ?? -1
-          : 0
-      },
+    column.getPinnedIndex = () => {
+      const position = column.getIsPinned()
+
+      return position
+        ? table.getState().columnPinning?.[position]?.indexOf(column.id) ?? -1
+        : 0
     }
   },
 
   createRow: <TData extends RowData>(
     row: Row<TData>,
     table: Table<TData>
-  ): ColumnPinningRow<TData> => {
-    return {
-      getCenterVisibleCells: memo(
-        () => [
-          row._getAllVisibleCells(),
-          table.getState().columnPinning.left,
-          table.getState().columnPinning.right,
-        ],
-        (allCells, left, right) => {
-          const leftAndRight: string[] = [...(left ?? []), ...(right ?? [])]
-
-          return allCells.filter(d => !leftAndRight.includes(d.column.id))
-        },
-        {
-          key:
-            process.env.NODE_ENV === 'production' &&
-            'row.getCenterVisibleCells',
-          debug: () => table.options.debugAll ?? table.options.debugRows,
-        }
-      ),
-      getLeftVisibleCells: memo(
-        () => [
-          row._getAllVisibleCells(),
-          table.getState().columnPinning.left,
-          ,
-        ],
-        (allCells, left) => {
-          const cells = (left ?? [])
-            .map(
-              columnId => allCells.find(cell => cell.column.id === columnId)!
-            )
-            .filter(Boolean)
-            .map(d => ({ ...d, position: 'left' } as Cell<TData, unknown>))
-
-          return cells
-        },
-        {
-          key:
-            process.env.NODE_ENV === 'production' && 'row.getLeftVisibleCells',
-          debug: () => table.options.debugAll ?? table.options.debugRows,
-        }
-      ),
-      getRightVisibleCells: memo(
-        () => [row._getAllVisibleCells(), table.getState().columnPinning.right],
-        (allCells, right) => {
-          const cells = (right ?? [])
-            .map(
-              columnId => allCells.find(cell => cell.column.id === columnId)!
-            )
-            .filter(Boolean)
-            .map(d => ({ ...d, position: 'right' } as Cell<TData, unknown>))
-
-          return cells
-        },
-        {
-          key:
-            process.env.NODE_ENV === 'production' && 'row.getRightVisibleCells',
-          debug: () => table.options.debugAll ?? table.options.debugRows,
-        }
-      ),
-    }
+  ): void => {
+    row.getCenterVisibleCells = memo(
+      () => [
+        row._getAllVisibleCells(),
+        table.getState().columnPinning.left,
+        table.getState().columnPinning.right,
+      ],
+      (allCells, left, right) => {
+        const leftAndRight: string[] = [...(left ?? []), ...(right ?? [])]
+
+        return allCells.filter(d => !leftAndRight.includes(d.column.id))
+      },
+      {
+        key:
+          process.env.NODE_ENV === 'production' && 'row.getCenterVisibleCells',
+        debug: () => table.options.debugAll ?? table.options.debugRows,
+      }
+    )
+    row.getLeftVisibleCells = memo(
+      () => [row._getAllVisibleCells(), table.getState().columnPinning.left, ,],
+      (allCells, left) => {
+        const cells = (left ?? [])
+          .map(columnId => allCells.find(cell => cell.column.id === columnId)!)
+          .filter(Boolean)
+          .map(d => ({ ...d, position: 'left' } as Cell<TData, unknown>))
+
+        return cells
+      },
+      {
+        key: process.env.NODE_ENV === 'production' && 'row.getLeftVisibleCells',
+        debug: () => table.options.debugAll ?? table.options.debugRows,
+      }
+    )
+    row.getRightVisibleCells = memo(
+      () => [row._getAllVisibleCells(), table.getState().columnPinning.right],
+      (allCells, right) => {
+        const cells = (right ?? [])
+          .map(columnId => allCells.find(cell => cell.column.id === columnId)!)
+          .filter(Boolean)
+          .map(d => ({ ...d, position: 'right' } as Cell<TData, unknown>))
+
+        return cells
+      },
+      {
+        key:
+          process.env.NODE_ENV === 'production' && 'row.getRightVisibleCells',
+        debug: () => table.options.debugAll ?? table.options.debugRows,
+      }
+    )
   },
 
-  createTable: <TData extends RowData>(
-    table: Table<TData>
-  ): ColumnPinningInstance<TData> => {
-    return {
-      setColumnPinning: updater =>
-        table.options.onColumnPinningChange?.(updater),
-
-      resetColumnPinning: defaultState =>
-        table.setColumnPinning(
-          defaultState
-            ? getDefaultPinningState()
-            : table.initialState?.columnPinning ?? getDefaultPinningState()
-        ),
-
-      getIsSomeColumnsPinned: position => {
-        const pinningState = table.getState().columnPinning
-
-        if (!position) {
-          return Boolean(
-            pinningState.left?.length || pinningState.right?.length
-          )
-        }
-        return Boolean(pinningState[position]?.length)
-      },
+  createTable: <TData extends RowData>(table: Table<TData>): void => {
+    table.setColumnPinning = updater =>
+      table.options.onColumnPinningChange?.(updater)
 
-      getLeftLeafColumns: memo(
-        () => [table.getAllLeafColumns(), table.getState().columnPinning.left],
-        (allColumns, left) => {
-          return (left ?? [])
-            .map(columnId => allColumns.find(column => column.id === columnId)!)
-            .filter(Boolean)
-        },
-        {
-          key: process.env.NODE_ENV === 'development' && 'getLeftLeafColumns',
-          debug: () => table.options.debugAll ?? table.options.debugColumns,
-        }
-      ),
-
-      getRightLeafColumns: memo(
-        () => [table.getAllLeafColumns(), table.getState().columnPinning.right],
-        (allColumns, right) => {
-          return (right ?? [])
-            .map(columnId => allColumns.find(column => column.id === columnId)!)
-            .filter(Boolean)
-        },
-        {
-          key: process.env.NODE_ENV === 'development' && 'getRightLeafColumns',
-          debug: () => table.options.debugAll ?? table.options.debugColumns,
-        }
-      ),
-
-      getCenterLeafColumns: memo(
-        () => [
-          table.getAllLeafColumns(),
-          table.getState().columnPinning.left,
-          table.getState().columnPinning.right,
-        ],
-        (allColumns, left, right) => {
-          const leftAndRight: string[] = [...(left ?? []), ...(right ?? [])]
-
-          return allColumns.filter(d => !leftAndRight.includes(d.id))
-        },
-        {
-          key: process.env.NODE_ENV === 'development' && 'getCenterLeafColumns',
-          debug: () => table.options.debugAll ?? table.options.debugColumns,
-        }
-      ),
+    table.resetColumnPinning = defaultState =>
+      table.setColumnPinning(
+        defaultState
+          ? getDefaultPinningState()
+          : table.initialState?.columnPinning ?? getDefaultPinningState()
+      )
+
+    table.getIsSomeColumnsPinned = position => {
+      const pinningState = table.getState().columnPinning
+
+      if (!position) {
+        return Boolean(pinningState.left?.length || pinningState.right?.length)
+      }
+      return Boolean(pinningState[position]?.length)
     }
+
+    table.getLeftLeafColumns = memo(
+      () => [table.getAllLeafColumns(), table.getState().columnPinning.left],
+      (allColumns, left) => {
+        return (left ?? [])
+          .map(columnId => allColumns.find(column => column.id === columnId)!)
+          .filter(Boolean)
+      },
+      {
+        key: process.env.NODE_ENV === 'development' && 'getLeftLeafColumns',
+        debug: () => table.options.debugAll ?? table.options.debugColumns,
+      }
+    )
+
+    table.getRightLeafColumns = memo(
+      () => [table.getAllLeafColumns(), table.getState().columnPinning.right],
+      (allColumns, right) => {
+        return (right ?? [])
+          .map(columnId => allColumns.find(column => column.id === columnId)!)
+          .filter(Boolean)
+      },
+      {
+        key: process.env.NODE_ENV === 'development' && 'getRightLeafColumns',
+        debug: () => table.options.debugAll ?? table.options.debugColumns,
+      }
+    )
+
+    table.getCenterLeafColumns = memo(
+      () => [
+        table.getAllLeafColumns(),
+        table.getState().columnPinning.left,
+        table.getState().columnPinning.right,
+      ],
+      (allColumns, left, right) => {
+        const leftAndRight: string[] = [...(left ?? []), ...(right ?? [])]
+
+        return allColumns.filter(d => !leftAndRight.includes(d.id))
+      },
+      {
+        key: process.env.NODE_ENV === 'development' && 'getCenterLeafColumns',
+        debug: () => table.options.debugAll ?? table.options.debugColumns,
+      }
+    )
   },
 }