react-science 16.0.0 → 17.0.0

package/src/components/table/table_root.tsx

@@ -1,21 +1,29 @@
 import { HTMLTable } from '@blueprintjs/core';
 import styled from '@emotion/styled';
-import type { Header, RowData, TableOptions } from '@tanstack/react-table';
+import type {
+  Header,
+  RowData,
+  Table as TanstackTable,
+  TableOptions,
+} from '@tanstack/react-table';
 import {
   getCoreRowModel,
   getSortedRowModel,
   useReactTable,
 } from '@tanstack/react-table';
 import { useVirtualizer } from '@tanstack/react-virtual';
-import type { ReactNode, RefObject, TableHTMLAttributes } from 'react';
-import { useEffect, useRef } from 'react';
+import type { RefObject, TableHTMLAttributes } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
+import { match } from 'ts-pattern';
 
-import { DroppedItemProvider } from './reorder_rows/dropped_item_provider.js';
+import { FlashedRowProvider } from './flash_row/flashed_row_provider.js';
+import type { PreviewTablePropsContextValue } from './preview_table_context.js';
+import { PreviewTablePropsContextProvider } from './preview_table_context.js';
 import { ItemOrderProvider } from './reorder_rows/item_order_provider.js';
-import { useDropMonitor } from './reorder_rows/use_drop_monitor.js';
 import { TableBody } from './table_body.js';
 import { TableHeader } from './table_header.js';
 import type { HeaderCellRenderer } from './table_header_cell.js';
+import { ScrollContainer } from './table_scroll_container.js';
 import type {
   GetTdProps,
   Scroller,
@@ -25,33 +33,40 @@ import type {
   VirtualScroller,
 } from './table_utils.js';
 import { useTableColumns } from './use_table_columns.js';
-import { useTableScroll } from './use_table_scroll.js';
+
+const nonForwardedProps = new Set<keyof TableProps<unknown>>([
+  'striped',
+  'stickyHeader',
+  'noHeader',
+]) as Set<string>;
 
 const CustomHTMLTable = styled(HTMLTable, {
-  shouldForwardProp: (prop) => prop !== 'striped' && prop !== 'stickyHeader',
-})<{ stickyHeader: boolean }>`
+  shouldForwardProp: (prop) => !nonForwardedProps.has(prop),
+})<{ stickyHeader: boolean; noHeader: boolean }>`
   /* When using a sticky header, ensure that the borders are located below the last header instead of above the first row. */
-  ${(props) => {
-    if (!props.stickyHeader) return '';
-
-    return `
+  ${(props) =>
+    match(props)
+      .with({ stickyHeader: false, noHeader: false }, () => '')
+      .otherwise(
+        (props) => `
       thead tr:last-child {
         box-shadow: inset 0 -1px #11141826;
       }
     
       tbody tr:first-of-type td {
-        box-shadow: ${
-          props.bordered
-            ? 'inset 1px 0 0 0 #11141826 !important'
-            : 'none !important'
-        };
+        box-shadow: ${match(props)
+          .with(
+            { bordered: true },
+            () => 'inset 1px 0 0 0 #11141826 !important',
+          )
+          .otherwise(() => 'none !important')};
       }
     
       tbody tr:first-of-type td:first-of-type {
         box-shadow: none !important;
       }
-    `;
-  }}
+    `,
+      )}
 
   /* Blueprint's HTMLTable \`striped\` prop's implementation is based on nth-child odd / even */
   /* We cannot use that with virtualization, so we override its implementation here. */
@@ -88,6 +103,10 @@ interface TableBaseProps<TData extends RowData> {
    * Alternate between gray and white background for each row.
    */
   striped?: boolean;
+  /**
+   * Do not render the table header.
+   */
+  noHeader?: boolean;
   /**
    * Enable header rows which stick to the top of the table.
    */
@@ -134,7 +153,7 @@ interface TableBaseProps<TData extends RowData> {
    * A ref which will be set with a callback to scroll to a row in the
    * table, specified by the row's ID.
    */
-  scrollToRowRef?: RefObject<VirtualScroller | ScrollToOptions | undefined>;
+  scrollToRowRef?: RefObject<VirtualScroller | Scroller | undefined>;
 
   /**
    * An accessor which should return a unique identifier for the row.
@@ -199,6 +218,7 @@ export function Table<TData extends RowData>(props: TableProps<TData>) {
     compact = false,
     interactive = false,
     striped = false,
+    noHeader = false,
     stickyHeader = false,
 
     reactTable,
@@ -212,9 +232,11 @@ export function Table<TData extends RowData>(props: TableProps<TData>) {
     getRowId,
     onRowOrderChanged,
     renderRowPreview,
+
+    scrollToRowRef,
   } = props;
   const isReorderingEnabled = !!onRowOrderChanged;
-  const scrollElementRef = useRef<HTMLDivElement>(null);
+  const virtualScrollElementRef = useRef<HTMLDivElement>(null);
   const columnDefs = useTableColumns(columns);
   const table = useReactTable<TData>({
     ...reactTable,
@@ -228,13 +250,13 @@ export function Table<TData extends RowData>(props: TableProps<TData>) {
   const tanstackVirtualizer = useVirtualizer({
     enabled: virtualizeRows,
     count: data.length,
-    getScrollElement: () => scrollElementRef.current,
+    getScrollElement: () => virtualScrollElementRef.current,
     estimateSize:
       (props.virtualizeRows && props.estimatedRowHeight) || (() => 0),
     overscan: 5,
   });
 
-  const tableRef = useTableScroll(props, table, tanstackVirtualizer);
+  const tableRef = useRef<HTMLTableElement>(null);
 
   // Make the table component compatible with styled components libraries.
   let finalClassName: string | undefined;
@@ -251,113 +273,80 @@ export function Table<TData extends RowData>(props: TableProps<TData>) {
     props as TableProps<unknown>,
     tableHeaders as Array<Header<unknown, unknown>>,
   );
+
+  const tablePreviewProps = useMemo<PreviewTablePropsContextValue<TData>>(
+    () => ({
+      className,
+      getTdProps,
+      renderRowTr,
+      columns,
+      compact,
+    }),
+    [className, getTdProps, renderRowTr, columns, compact],
+  );
   return (
-    <DroppedItemProvider>
-      <ItemOrderProvider
-        items={table.getRowModel().rows}
-        onOrderChanged={(items) => {
-          onRowOrderChanged?.(items.map((item) => item.original));
-        }}
+    <FlashedRowProvider>
+      <PreviewTablePropsContextProvider
+        value={tablePreviewProps as PreviewTablePropsContextValue<unknown>}
       >
-        <Container
-          virtualizeRows={virtualizeRows}
-          scrollRef={
-            virtualizeRows
-              ? scrollElementRef
-              : props.scrollableElementRef || tableRef
-          }
-          isReorderingEnabled={isReorderingEnabled}
+        <ItemOrderProvider
+          items={table.getRowModel().rows}
+          onOrderChanged={(items) => {
+            onRowOrderChanged?.(items.map((item) => item.original));
+          }}
         >
-          <CustomHTMLTable
-            ref={tableRef}
-            bordered={bordered}
-            compact={compact}
-            interactive={interactive}
-            striped={striped}
-            stickyHeader={stickyHeader}
-            {...tableProps}
-            className={finalClassName}
+          <ScrollContainer
+            virtualizeRows={virtualizeRows}
+            virtualizer={tanstackVirtualizer}
+            table={table as TanstackTable<unknown>}
+            scrollRef={
+              virtualizeRows
+                ? // When virtualized, ScrollContainer will render a scrollable element associated to this ref.
+                  virtualScrollElementRef
+                : // When not virtualized, ScrollContainer does not render a container, only its children,
+                  // And the scrollable element is provided by the user or by default, the <table> element.
+                  props.scrollableElementRef || tableRef
+            }
+            scrollToRowRef={scrollToRowRef}
+            isReorderingEnabled={isReorderingEnabled}
           >
-            <TableHeader
-              sticky={stickyHeader}
-              headers={tableHeaders}
-              renderHeaderCell={renderHeaderCell}
-            />
-            <TableBody
-              rows={table.getRowModel().rows}
-              renderRowTr={renderRowTr}
-              getTdProps={getTdProps}
-              virtualizer={tanstackVirtualizer}
-              virtualizeRows={virtualizeRows}
-              renderRowPreview={renderRowPreview}
-              isReorderingEnabled={isReorderingEnabled}
-            />
-          </CustomHTMLTable>
-        </Container>
-      </ItemOrderProvider>
-    </DroppedItemProvider>
-  );
-}
-
-const ScrollRefDiv = styled.div`
-  height: 100%;
-  overflow: auto;
-`;
-
-interface ContainerProps {
-  virtualizeRows?: boolean;
-  children: ReactNode;
-  scrollRef: RefObject<Element>;
-  isReorderingEnabled: boolean;
-}
-
-function Container(props: ContainerProps) {
-  const { virtualizeRows, scrollRef, isReorderingEnabled, children } = props;
-  if (virtualizeRows) {
-    return (
-      <ContainerVirtual
-        scrollElementRef={scrollRef}
-        enabled={isReorderingEnabled}
-      >
-        {children}
-      </ContainerVirtual>
-    );
-  }
-  return (
-    <ContainerTable scrollElementRef={scrollRef} enabled={isReorderingEnabled}>
-      {children}
-    </ContainerTable>
+            <CustomHTMLTable
+              // Props which are not forwarded to the HTMLTable component
+              striped={striped}
+              noHeader={noHeader}
+              stickyHeader={stickyHeader}
+              // Props which are forwarded to the HTMLTable component
+              ref={tableRef}
+              bordered={bordered}
+              compact={compact}
+              interactive={interactive}
+              {...tableProps}
+              className={finalClassName}
+            >
+              {!noHeader && (
+                <TableHeader
+                  sticky={stickyHeader}
+                  headers={tableHeaders}
+                  renderHeaderCell={renderHeaderCell}
+                />
+              )}
+              <TableBody
+                rows={table.getRowModel().rows}
+                renderRowTr={renderRowTr}
+                getTdProps={getTdProps}
+                virtualizer={tanstackVirtualizer}
+                virtualizeRows={virtualizeRows}
+                renderRowPreview={renderRowPreview}
+                isReorderingEnabled={isReorderingEnabled}
+              />
+            </CustomHTMLTable>
+          </ScrollContainer>
+        </ItemOrderProvider>
+      </PreviewTablePropsContextProvider>
+    </FlashedRowProvider>
   );
 }
 
-interface ContainerWithReorderingProps {
-  scrollElementRef: RefObject<Element>;
-  enabled: boolean;
-  children: ReactNode;
-}
-
-function ContainerVirtual(props: ContainerWithReorderingProps) {
-  const { scrollElementRef, enabled, children } = props;
-  useDropMonitor(scrollElementRef, enabled);
-
-  return (
-    <ScrollRefDiv ref={scrollElementRef as RefObject<HTMLDivElement>}>
-      {children}
-    </ScrollRefDiv>
-  );
-}
-
-interface ContainerTableProps {
-  scrollElementRef: RefObject<Element>;
-  enabled: boolean;
-  children: ReactNode;
-}
-function ContainerTable(props: ContainerTableProps) {
-  const { scrollElementRef, enabled, children } = props;
-  useDropMonitor(scrollElementRef, enabled);
-  return <>{children}</>;
-}
-
 function useCheckProps(
   props: TableProps<unknown>,
   headers: Array<Header<unknown, unknown>>,

package/src/components/table/table_row.tsx

@@ -0,0 +1,17 @@
+import type { Row } from '@tanstack/react-table';
+import type { JSX } from 'react';
+import { useRef } from 'react';
+
+import { useFlashRowEffect } from './flash_row/use_flash_row_effect.js';
+
+export interface TableRowTrProps {
+  row: Row<unknown>;
+  trProps: JSX.IntrinsicElements['tr'];
+}
+
+export function TableRowTr(props: TableRowTrProps) {
+  const { row, trProps } = props;
+  const tableRowRef = useRef<HTMLTableRowElement>(null);
+  useFlashRowEffect(row.id, tableRowRef);
+  return <tr ref={tableRowRef} {...trProps} />;
+}

package/src/components/table/table_scroll_container.tsx

@@ -0,0 +1,103 @@
+import styled from '@emotion/styled';
+import type { Virtualizer } from '@tanstack/react-virtual';
+import type { Table as TanstackTable } from '@tanstack/table-core';
+import type { ReactNode, RefObject } from 'react';
+
+import { useDropMonitor } from './reorder_rows/use_drop_monitor.js';
+import type { TableProps } from './table_root.js';
+import { useTableScroll } from './use_table_scroll.js';
+
+const ScrollRefDiv = styled.div`
+  height: 100%;
+  overflow: auto;
+`;
+
+interface ScrollContainerProps {
+  /**
+   * Whether the table rows are virtualized.
+   */
+  virtualizeRows?: boolean;
+  /**
+   * The tanstack virtualizer.
+   */
+  virtualizer: Virtualizer<HTMLDivElement, Element>;
+  /**
+   * The tanstack table.
+   */
+  table: TanstackTable<unknown>;
+  /**
+   * A ref to the effective scroll container.
+   */
+  scrollRef: RefObject<Element>;
+  /**
+   * The user provided ref to attach the scroll callbacks to.
+   * It is set by the ScrollContainer component if the table is virtualized.
+   * It is an external ref when the table is not virtualized.
+   */
+  scrollToRowRef?: TableProps<unknown>['scrollToRowRef'];
+  isReorderingEnabled: boolean;
+  children: ReactNode;
+}
+
+export function ScrollContainer(props: ScrollContainerProps) {
+  const {
+    virtualizeRows,
+    table,
+    virtualizer,
+    scrollRef,
+    scrollToRowRef,
+    isReorderingEnabled,
+    children,
+  } = props;
+  useTableScroll({
+    virtualizeRows,
+    table,
+    virtualizer,
+    scrollRef,
+    scrollToRowRef,
+  });
+  if (virtualizeRows) {
+    return (
+      <ContainerVirtual
+        scrollElementRef={scrollRef}
+        isReorderingEnabled={isReorderingEnabled}
+      >
+        {children}
+      </ContainerVirtual>
+    );
+  }
+  return (
+    <NoContainer scrollElementRef={scrollRef} enabled={isReorderingEnabled}>
+      {children}
+    </NoContainer>
+  );
+}
+
+interface ContainerWithReorderingProps {
+  scrollElementRef: RefObject<Element>;
+  isReorderingEnabled: boolean;
+  children: ReactNode;
+}
+
+function ContainerVirtual(props: ContainerWithReorderingProps) {
+  const { scrollElementRef, isReorderingEnabled, children } = props;
+  useDropMonitor(scrollElementRef, isReorderingEnabled);
+
+  return (
+    <ScrollRefDiv ref={scrollElementRef as RefObject<HTMLDivElement>}>
+      {children}
+    </ScrollRefDiv>
+  );
+}
+
+interface NoContainerProps {
+  scrollElementRef: RefObject<Element>;
+  enabled: boolean;
+  children: ReactNode;
+}
+
+function NoContainer(props: NoContainerProps) {
+  const { scrollElementRef, enabled, children } = props;
+  useDropMonitor(scrollElementRef, enabled);
+  return <>{children}</>;
+}

package/src/components/table/table_utils.ts

@@ -18,7 +18,7 @@ export function createTableColumnHelper<TData extends RowData>() {
   return createColumnHelper<TData>();
 }
 
-export interface TableRowTrProps {
+export interface TableRowTrRenderProps {
   className: string;
   style: CSSProperties;
   children: ReactNode;
@@ -27,7 +27,7 @@ export interface TableRowTrProps {
 }
 
 export type TableRowTrRenderer<TData extends RowData> = (
-  trProps: TableRowTrProps,
+  trProps: TableRowTrRenderProps,
   row: Row<TData>,
 ) => ReactNode;
 
@@ -38,10 +38,26 @@ export type TableRowPreviewRenderer<TData extends RowData> = (
   row: Row<TData>,
 ) => ReactNode;
 
+interface FlashRowOptions {
+  /**
+   * Whether to flash the row when scrolling into view.
+   * The option is only supported when there is no scroll animation, i.e. `behavior` is not `smooth`.
+   */
+  flashRow?: boolean;
+}
+
+export type TableScrollIntoViewOptions = ScrollIntoViewOptions &
+  FlashRowOptions;
+export type TableVirtualScrollIntoViewOptions = ScrollToOptions &
+  FlashRowOptions;
+
 export interface VirtualScroller {
-  scrollIntoView: (id: string, options?: ScrollToOptions) => void;
+  scrollIntoView: (
+    id: string,
+    options?: TableVirtualScrollIntoViewOptions,
+  ) => void;
 }
 
 export interface Scroller {
-  scrollIntoView: (id: string, options?: ScrollIntoViewOptions) => void;
+  scrollIntoView: (id: string, options?: TableScrollIntoViewOptions) => void;
 }

package/src/components/table/use_table_scroll.ts

@@ -1,26 +1,46 @@
 import type { RowData, Table } from '@tanstack/react-table';
-import type {
-  ScrollToOptions,
-  ScrollToOptions as VirtualScrollToOptions,
-  Virtualizer,
-} from '@tanstack/react-virtual';
-import { useImperativeHandle, useRef } from 'react';
+import type { Virtualizer } from '@tanstack/react-virtual';
+import type { RefObject } from 'react';
+import { useImperativeHandle } from 'react';
 
+import { useFlashedRowContext } from './flash_row/flashed_row_context.js';
 import type { TableProps } from './table_root.js';
+import type { TableVirtualScrollIntoViewOptions } from './table_utils.js';
 
-export function useTableScroll<TData extends RowData>(
-  tableProps: TableProps<TData>,
-  table: Table<TData>,
-  virtualizer: Virtualizer<HTMLDivElement, Element>,
-) {
-  const tableRef = useRef<HTMLTableElement>(null);
-  const { scrollToRowRef, virtualizeRows } = tableProps;
+export function useTableScroll<TData extends RowData>(options: {
+  /**
+   * The user provided ref to attach the scroll callbacks to.
+   */
+  scrollToRowRef: TableProps<TData>['scrollToRowRef'];
+  /**
+   * Whether the table rows are virtualized.
+   */
+  virtualizeRows: TableProps<TData>['virtualizeRows'];
+  /**
+   * A ref to the effective scroll container.
+   */
+  scrollRef: RefObject<Element>;
+  /*
+  Tanstack table instance.
+   */
+  table: Table<TData>;
+  /**
+   * Tanstack virtualizer instance.
+   */
+  virtualizer: Virtualizer<HTMLDivElement, Element>;
+}) {
+  const [, setFlashedRow] = useFlashedRowContext();
+  const { scrollToRowRef, virtualizeRows, scrollRef, table, virtualizer } =
+    options;
 
   // @ts-expect-error We cannot call the hook conditionally to satisfy the type checker
   useImperativeHandle(scrollToRowRef, () => {
     if (virtualizeRows) {
       return {
-        scrollIntoView(id: string, options?: VirtualScrollToOptions) {
+        scrollIntoView(
+          id: string,
+          options?: TableVirtualScrollIntoViewOptions,
+        ) {
           const sortedRows = table.getRowModel().rows; // Get sorted rows
           const rowIndex = sortedRows.findIndex((row) => row.id === id); // Find the index of the row by ID
           if (rowIndex === -1) {
@@ -29,14 +49,21 @@ export function useTableScroll<TData extends RowData>(
             console.warn(
               `Could not scroll to row with ID ${id}, the row does not exist`,
             );
+          } else {
+            virtualizer.scrollToIndex(rowIndex, options);
+            if (options?.flashRow && options.behavior !== 'smooth') {
+              setFlashedRow(sortedRows[rowIndex].id);
+            }
           }
-          virtualizer.scrollToIndex(rowIndex, options);
         },
       };
     } else {
       return {
-        scrollIntoView(id: string, options?: ScrollToOptions) {
-          const element = tableRef.current?.querySelector(
+        scrollIntoView(
+          id: string,
+          options?: TableVirtualScrollIntoViewOptions,
+        ) {
+          const element = scrollRef.current?.querySelector(
             `tr[data-row-id="${id}"]`,
           );
           if (!element) {
@@ -46,10 +73,11 @@ export function useTableScroll<TData extends RowData>(
             );
           }
           element?.scrollIntoView(options);
+          if (options?.flashRow && options.behavior !== 'smooth') {
+            setFlashedRow(id);
+          }
         },
       };
     }
-  }, [virtualizeRows, table, virtualizer]);
-
-  return tableRef;
+  }, [virtualizeRows, scrollRef, table, virtualizer, setFlashedRow]);
 }

package/lib/components/table/reorder_rows/dropped_item_context.d.ts

@@ -1,3 +0,0 @@
-export declare const droppedItemContext: import("react").Context<[string | undefined, import("react").Dispatch<import("react").SetStateAction<string | undefined>>] | null>;
-export declare function useDroppedItemContext(): [string | undefined, import("react").Dispatch<import("react").SetStateAction<string | undefined>>];
-//# sourceMappingURL=dropped_item_context.d.ts.map

package/lib/components/table/reorder_rows/dropped_item_context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dropped_item_context.d.ts","sourceRoot":"","sources":["../../../../src/components/table/reorder_rows/dropped_item_context.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,kBAAkB,oIAE9B,CAAC;AAEF,wBAAgB,qBAAqB,uGAUpC"}

package/lib/components/table/reorder_rows/dropped_item_context.js

@@ -1,10 +0,0 @@
-import { createContext, useContext } from 'react';
-export const droppedItemContext = createContext(null);
-export function useDroppedItemContext() {
-    const context = useContext(droppedItemContext);
-    if (!context) {
-        throw new Error('useDroppedItemId must be used within a DroppedItemProvider');
-    }
-    return context;
-}
-//# sourceMappingURL=dropped_item_context.js.map

package/lib/components/table/reorder_rows/dropped_item_context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dropped_item_context.js","sourceRoot":"","sources":["../../../../src/components/table/reorder_rows/dropped_item_context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAOlD,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAC7C,IAAI,CACL,CAAC;AAEF,MAAM,UAAU,qBAAqB;IACnC,MAAM,OAAO,GAAG,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAE/C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,4DAA4D,CAC7D,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/lib/components/table/reorder_rows/dropped_item_provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dropped_item_provider.d.ts","sourceRoot":"","sources":["../../../../src/components/table/reorder_rows/dropped_item_provider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAOjE"}

package/lib/components/table/reorder_rows/dropped_item_provider.js

@@ -1,8 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useState } from 'react';
-import { droppedItemContext } from './dropped_item_context.js';
-export function DroppedItemProvider(props) {
-    const value = useState();
-    return (_jsx(droppedItemContext.Provider, { value: value, children: props.children }));
-}
-//# sourceMappingURL=dropped_item_provider.js.map

package/lib/components/table/reorder_rows/dropped_item_provider.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dropped_item_provider.js","sourceRoot":"","sources":["../../../../src/components/table/reorder_rows/dropped_item_provider.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D,MAAM,UAAU,mBAAmB,CAAC,KAA8B;IAChE,MAAM,KAAK,GAAG,QAAQ,EAAU,CAAC;IACjC,OAAO,CACL,KAAC,kBAAkB,CAAC,QAAQ,IAAC,KAAK,EAAE,KAAK,YACtC,KAAK,CAAC,QAAQ,GACa,CAC/B,CAAC;AACJ,CAAC"}

package/src/components/table/reorder_rows/dropped_item_context.ts

@@ -1,23 +0,0 @@
-import type { useState } from 'react';
-import { createContext, useContext } from 'react';
-
-/**
- * ID of the dropped item
- */
-type DroppedItemContextValue = ReturnType<typeof useState<string>>;
-
-export const droppedItemContext = createContext<DroppedItemContextValue | null>(
-  null,
-);
-
-export function useDroppedItemContext() {
-  const context = useContext(droppedItemContext);
-
-  if (!context) {
-    throw new Error(
-      'useDroppedItemId must be used within a DroppedItemProvider',
-    );
-  }
-
-  return context;
-}

package/src/components/table/reorder_rows/dropped_item_provider.tsx

@@ -1,13 +0,0 @@
-import { useState } from 'react';
-import type { ReactNode } from 'react';
-
-import { droppedItemContext } from './dropped_item_context.js';
-
-export function DroppedItemProvider(props: { children: ReactNode }) {
-  const value = useState<string>();
-  return (
-    <droppedItemContext.Provider value={value}>
-      {props.children}
-    </droppedItemContext.Provider>
-  );
-}