@react-fabric/data 1.0.0-beta.3 → 1.0.0-beta.31

package/src/table/Table.tsx

@@ -21,12 +21,25 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import { EmptyContent, Loading, useDebounce } from "@react-fabric/core";
+import {
+  CoreIcons,
+  EmptyContent,
+  Icon,
+  Loading,
+  useDebounce,
+} from "@react-fabric/core";
+import { debounce } from "@react-fabric/utilities";
 import classNames from "classnames";
-import { useImperativeHandle, useMemo, useRef } from "react";
+import {
+  useEffect,
+  useImperativeHandle,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+} from "react";
 import { useTranslation } from "react-i18next";
 import { AddColumn } from "./AddColumn";
-import { BodyCell } from "./BodyCell";
+import { BodyRow } from "./BodyRow";
 import { CheckboxCell } from "./CheckboxCell";
 import { TableProvider } from "./Context";
 import { EmptyCell } from "./EmptyCell";
@@ -39,12 +52,20 @@ export const Table = <T extends KeyValue = KeyValue>({
   ref,
   data,
   columns,
-  keyProperty,
+  keyProperty = "id",
+  groupProperty,
   checkableRows,
+  initialScroll,
   hideableColumns,
   sort,
   loading,
+  checked,
+  emptyDisplay,
+  groupRenderer,
+  canExpand,
+  children,
   onSort,
+  onScroll,
   onRowClick,
   onCheckedChanged,
 }: TableProps<T>) => {
@@ -58,13 +79,24 @@ export const Table = <T extends KeyValue = KeyValue>({
   const {
     scrollerRef,
     items,
+    top,
     checkState,
+    virtualizer,
+    hasActiveSticky,
+    toggleExpand,
     toggleChecked,
     toggleAllChecked,
+    toggleGroupExpand,
     getData,
     totalSize,
+    isActiveSticky,
     measureElement,
-  } = useVirtualTable(data, keyProperty, fireCheckChanged);
+  } = useVirtualTable(data, {
+    checked,
+    keyProperty,
+    groupProperty,
+    onCheckChanged: fireCheckChanged,
+  });
   const refBody = useRef<HTMLDivElement>(null);
 
   const wrapperStart = useMemo(
@@ -76,32 +108,51 @@ export const Table = <T extends KeyValue = KeyValue>({
     [],
   );
 
+  useLayoutEffect(() => {
+    setTimeout(() => {
+      initialScroll &&
+        virtualizer.scrollToIndex(initialScroll, { align: "start" });
+    }, 100);
+  }, []);
+
   useImperativeHandle(
     ref,
     () => ({
-      hilight: (row: number) => {
-        refBody.current
-          ?.querySelectorAll<HTMLElement>(`.datatable-row[data-hilight="true"]`)
-          .forEach((el) => el && (el.dataset.hilight = undefined));
-        const el = refBody.current?.querySelector<HTMLElement>(
-          `[data-row="${row}"]`,
-        );
-        el?.scrollIntoView({ behavior: "smooth", block: "center" });
-        el && (el.dataset.hilight = "true");
+      scrollTo: (row: number) => {
+        virtualizer.scrollToIndex(row, { align: "start" });
       },
-      unhilight: () => {
-        refBody.current
-          ?.querySelectorAll<HTMLElement>(`.datatable-row[data-hilight="true"]`)
-          .forEach((el) => el && (el.dataset.hilight = undefined));
+      hilight(row) {
+        scrollerRef.current
+          ?.querySelector(".hilight")
+          ?.classList.remove("hilight", "ring-1");
+        virtualizer.scrollToIndex(Math.floor(row), {
+          align: "start",
+        });
+        setTimeout(() => {
+          scrollerRef.current
+            ?.querySelector(`[data-index="${row}"]`)
+            ?.classList.add("hilight", "ring-1");
+        }, 100);
       },
-      scrollTo: (row: number) => {
-        const el = refBody.current?.querySelector(`[data-row="${row}"]`);
-        el?.scrollIntoView({ behavior: "smooth" });
+      unhilight() {
+        scrollerRef.current
+          ?.querySelector(".hilight")
+          ?.classList.remove("hilight", "ring-1");
       },
     }),
     [],
   );
 
+  useEffect(() => {
+    const handle = debounce((top: number) => {
+      onScroll?.(top ?? 0);
+    });
+    handle(top);
+    return () => {
+      handle.cancel();
+    };
+  }, [top]);
+
   return (
     <TableProvider>
       <div
@@ -109,10 +160,15 @@ export const Table = <T extends KeyValue = KeyValue>({
         style={{
           gridTemplate: `"head" auto "loader" auto "content" 1fr "foot" auto/1fr`,
         }}
+        data-ref="tableScroller"
         ref={scrollerRef}
       >
-        <div className="bg-base font-medium sticky top-0 area-head border-b select-none flex flex-nowrap z-2">
+        <div
+          data-ref="tableHeader"
+          className="bg-base font-medium sticky top-0 area-head border-b select-none flex flex-nowrap z-2"
+        >
           <div className={wrapperStart}>
+            {canExpand && <div className="w-6" />}
             {checkableRows && (
               <CheckboxCell
                 state={checkState.allChecked}
@@ -146,62 +202,72 @@ export const Table = <T extends KeyValue = KeyValue>({
             style={{ height: totalSize() }}
             ref={refBody}
           >
-            <div style={{ height: items[0]?.start }} />
+            <div
+              style={{
+                height: items[hasActiveSticky ? 1 : 0]?.start,
+              }}
+            />
             {items.map(({ index, key }) => {
               const data = getData(index);
-              return (
+              return "__GROUP__" in data ? (
                 <div
                   key={key}
-                  role="none"
-                  data-row={index}
+                  ref={measureElement}
+                  data-index={index}
                   className={classNames(
-                    "flex flex-nowrap datatable-row data-[hilight]:outline-1 -outline-offset-1 outline-primary-500",
-                    index % 2 ? "bg-even" : "bg-odd",
-                    onRowClick && "hover:bg-primary-50 active:bg-primary-100",
+                    "px-2 py-1 text-md bg-base border-y border-tint-100 cursor-pointer flex items-center gap-1",
+                    isActiveSticky(index) && "sticky top-8 z-30",
                   )}
-                  onClick={() =>
-                    checkableRows && !onRowClick
-                      ? toggleChecked(data[keyProperty])
-                      : onRowClick?.(data)
-                  }
-                  data-index={index}
-                  ref={measureElement}
+                  role="none"
+                  onClick={() => toggleGroupExpand(data.key)}
                 >
-                  <div className={wrapperStart}>
-                    {checkableRows && (
-                      <CheckboxCell
-                        onClick={() => toggleChecked(data[keyProperty])}
-                        state={
-                          checkState.checked.includes(data[keyProperty]) ? 1 : 0
-                        }
-                      />
-                    )}
-                    {state.start?.map((col, ids) => (
-                      <BodyCell
-                        key={`${key}:${ids}`}
-                        column={col}
-                        item={data}
-                      />
-                    ))}
-                  </div>
-                  {state.cols?.map((col, idc) => (
-                    <BodyCell key={`${key}:${idc}`} column={col} item={data} />
-                  ))}
-                  <div className={wrapperEnd}>
-                    {state.end?.map((col, ide) => (
-                      <BodyCell
-                        key={`${key}:${ide}`}
-                        column={col}
-                        item={data}
-                      />
-                    ))}
-                    {hideableColumns && <div className="w-6" />}
-                  </div>
+                  <Icon
+                    rtlFlip
+                    icon={
+                      data.open ? CoreIcons.chevronDown : CoreIcons.chevronRight
+                    }
+                  />
+                  {groupRenderer?.(data) ?? (
+                    <div className="flex gap-1 items-center">
+                      <span>{data.key}</span>
+                      <span className="text-sm">({data.itemCount})</span>
+                    </div>
+                  )}
                 </div>
+              ) : (
+                <BodyRow
+                  rowKey={key}
+                  index={index}
+                  checkableRows={checkableRows}
+                  checked={
+                    keyProperty &&
+                    checkState.checked.includes(data[keyProperty])
+                      ? 1
+                      : 0
+                  }
+                  expanded={
+                    !!keyProperty &&
+                    checkState.expanded.includes(data[keyProperty])
+                  }
+                  data={data}
+                  hideableColumns={hideableColumns}
+                  keyProperty={keyProperty}
+                  measureElement={measureElement}
+                  onRowClick={onRowClick}
+                  state={state}
+                  canExpand={canExpand}
+                  toggleExpand={toggleExpand}
+                  expandRow={children}
+                  toggleChecked={toggleChecked}
+                  wrapperEnd={wrapperEnd}
+                  wrapperStart={wrapperStart}
+                  key={key}
+                />
               );
             })}
             <div className="flex-1 flex flex-nowrap">
               <div className={wrapperStart}>
+                {canExpand && <div className="w-6" />}
                 {checkableRows && <div className="w-6" />}
                 {state.start?.map((col) => (
                   <EmptyCell key={String(col.id)} {...col} />
@@ -220,13 +286,15 @@ export const Table = <T extends KeyValue = KeyValue>({
             </div>
           </div>
         )}
-        {!loading && data.length === 0 && (
-          <EmptyContent
-            size="sm"
-            className="bg-dimmed"
-            message={t("datagrid.empty")}
-          />
-        )}
+        {!loading &&
+          data.length === 0 &&
+          (emptyDisplay ?? (
+            <EmptyContent
+              size="sm"
+              className="bg-dimmed"
+              message={t("datagrid.empty")}
+            />
+          ))}
       </div>
     </TableProvider>
   );

package/src/table/types.ts

@@ -23,6 +23,7 @@
 
 import {
   type CssProp,
+  type Elements,
   type IconProps,
   type RefProp,
   type TestProps,
@@ -33,16 +34,18 @@ export const COL_MIN_WIDTH = "3rem";
 export const COL_MAX_WIDTH = "64rem";
 export const COL_DEFAULT_WIDTH = "12rem";
 
-export interface ColumnType<T = KeyValue>
+export interface TableColumn<T = KeyValue>
   extends CssProp,
     IconProps,
     TestProps {
-  id: keyof T;
+  id: keyof T | string;
   label?: string;
-  actions?: ReactElement;
+  tooltip?: string;
+  actions?: ReactElement[];
   align?: "start" | "center" | "end";
   locked?: "start" | "end";
   hidden?: boolean;
+  truncate?: boolean;
   hideable?: boolean;
   resizable?: boolean;
   sortable?: boolean;
@@ -60,7 +63,8 @@ export interface ColumnType<T = KeyValue>
     | "time"
     | "unknown";
   format?: string;
-  renderer?: (value: AnyObject, data: T) => void;
+  valueMap?: KeyValue;
+  renderer?: (value: AnyObject, data: T, index: number) => Elements<AnyObject>;
 }
 
 export interface TableRef {
@@ -70,14 +74,19 @@ export interface TableRef {
 }
 
 export interface TableProps<T = KeyValue> extends RefProp<TableRef> {
-  columns: Array<ColumnType<T>>;
+  columns: Array<TableColumn<T>>;
   data: T[];
-  keyProperty: keyof T;
+  keyProperty?: keyof T;
+  groupProperty?: keyof T;
+  groupRenderer?: (key: AnyObject) => ReactElement;
+  emptyDisplay?: ReactElement;
+
   /**
    * checkable rows
    */
+  checked?: AnyObject[];
   checkableRows?: boolean;
-  onCheckedChanged?: (rows: Array<keyof T>) => void;
+  onCheckedChanged?: (rows: AnyObject[]) => void;
   /**
    * sorting
    */
@@ -88,4 +97,10 @@ export interface TableProps<T = KeyValue> extends RefProp<TableRef> {
   hideableColumns?: boolean;
 
   onRowClick?: (data: T) => void;
+
+  initialScroll?: number;
+  onScroll?: (firstItem: number) => void;
+
+  canExpand?: (record: T) => boolean;
+  children?: (record: T) => Elements<AnyObject>;
 }

package/src/table/useResizer.ts

@@ -47,13 +47,15 @@ export const useResizer = (
   /** ***************** attach handlers *******************/
   const box = colEl.getBoundingClientRect();
   if (colEl.parentElement != null) {
-    const parentBox = colEl.parentElement?.getBoundingClientRect();
+    const parentBox = colEl
+      .closest("[data-ref='tableScroller']")
+      ?.getBoundingClientRect() as unknown as DOMRect;
     if (isRtl) {
       placeholder.style.left = "unset";
-      placeholder.style.right = `${box.right - parentBox.right}px`;
+      placeholder.style.right = `${parentBox.width - box.right}px`;
     } else {
       placeholder.style.right = "unset";
-      placeholder.style.left = `${box.left - parentBox.left}px`;
+      placeholder.style.left = `${box.left}px`;
     }
   }
   placeholder.style.width = `${colEl.offsetWidth}px`;

package/src/table/useTableColumns.ts

@@ -23,20 +23,20 @@
 
 import { groupBy } from "@react-fabric/utilities";
 import { useEffect, useReducer } from "react";
-import { type ColumnType } from "./types";
+import { type TableColumn } from "./types";
 
 interface ColumnState {
-  columns: ColumnType[];
-  start: ColumnType[];
-  end: ColumnType[];
-  cols: ColumnType[];
+  columns: TableColumn[];
+  start: TableColumn[];
+  end: TableColumn[];
+  cols: TableColumn[];
 }
 
 type ColumnActions =
-  | { type: "columns"; columns: ColumnType[] }
+  | { type: "columns"; columns: TableColumn[] }
   | { type: "hide"; id: string };
 
-export const useTableColumns = (columns: ColumnType[]) => {
+export const useTableColumns = (columns: TableColumn[]) => {
   const [state, dispatch] = useReducer(
     (state: ColumnState, action: ColumnActions) => {
       if (action.type === "columns") {

package/src/table/useVirtualTable.ts

@@ -21,78 +21,193 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import { useVirtualizer } from "@tanstack/react-virtual";
-import { useCallback, useReducer, useRef } from "react";
+import { compareValues, groupBy } from "@react-fabric/utilities";
+import {
+  defaultRangeExtractor,
+  type Range,
+  useVirtualizer,
+} from "@tanstack/react-virtual";
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+} from "react";
 
-interface DataState {
-  checked: Key[];
+interface DataState<T = KeyValue> {
+  items: T[];
+  grouped: KeyValue<T[]>;
+  groups: AnyObject[];
+  expanded: AnyObject[];
+  checked: AnyObject[];
   allChecked: 0 | 1 | 2;
 }
 
-type DataAction = { type: "check"; key: Key } | { type: "checkall" };
+type DataAction =
+  | { type: "updateState"; checked: AnyObject[] }
+  | { type: "groupExpand"; key: AnyObject }
+  | { type: "grouped"; key: AnyObject }
+  | { type: "expand"; key: AnyObject }
+  | { type: "check"; key: AnyObject }
+  | { type: "checkall" };
 
-export const useVirtualTable = (
-  data: KeyValue[],
-  keyProperty: Key,
-  onCheckChanged: (checked: Key[]) => void,
+export const useVirtualTable = <T extends KeyValue = KeyValue>(
+  data: T[],
+  options: {
+    checked?: AnyObject[];
+    keyProperty: keyof T;
+    groupProperty?: keyof T;
+    onCheckChanged?: (checked: AnyObject[]) => void;
+  },
 ) => {
   // TODO: refactor data into item list, apply grouping if groupColumn provided
   // TODO: when grouping maintain map of group with children, {___GROUP___:true, label, items, open}
 
-  const scrollerRef = useRef<HTMLDivElement>(null);
-  const virtualizer = useVirtualizer({
-    count: data.length,
-    getScrollElement: () => scrollerRef.current,
-    estimateSize: () => 24,
-  });
-
   const [state, dispatch] = useReducer(
-    (state: DataState, action: DataAction) => {
+    (state: DataState<T>, action: DataAction) => {
+      if (action.type === "updateState") {
+        state.checked = action.checked;
+      }
+      if (action.type === "expand") {
+        if (state.expanded.includes(action.key))
+          state.expanded.splice(state.expanded.indexOf(action.key), 1);
+        else state.expanded.push(action.key);
+      }
       if (action.type === "check") {
         if (state.checked.includes(action.key))
           state.checked.splice(state.checked.indexOf(action.key), 1);
         else state.checked.push(action.key);
+        options.onCheckChanged?.(state.checked);
       }
       if (action.type === "checkall") {
         if (state.allChecked !== 0) {
           state.checked = [];
+        } else if (options.keyProperty) {
+          state.checked = data.map((item) => item[options.keyProperty]);
+        }
+        options.onCheckChanged?.(state.checked);
+      }
+      const checkList = data.filter((hit) =>
+        state.checked.includes(hit[options.keyProperty]),
+      );
+      if (action.type === "groupExpand") {
+        const group = state.groups.find((group) => group.key === action.key);
+        if (group) {
+          group.open = !group.open;
+          state.groups = state.groups.slice();
+          state.items = state.groups
+            .map((group) => [
+              group,
+              group.open ? state.grouped[group.key] : undefined,
+            ])
+            .flat(2)
+            .filter(Boolean) as any;
+        }
+      }
+      if (action.type === "grouped") {
+        if (action.key) {
+          state.grouped = groupBy<T>(data, action.key);
+          state.groups = Object.keys(state.grouped)
+            .sort(compareValues("asc"))
+            .map((group) => ({
+              __GROUP__: true,
+              open: true,
+              key: group,
+              items: state.grouped[group],
+              itemCount: state.grouped[group].length,
+            }));
+          state.items = state.groups
+            .map((group) => [group, ...state.grouped[group.key]])
+            .flat() as any;
         } else {
-          state.checked = data.map((item) => item[keyProperty]);
+          state.items = data;
         }
       }
-      onCheckChanged(state.checked);
       return {
         ...state,
         allChecked:
-          state.checked.length === data.length
-            ? 1
-            : state.checked.length
-              ? 2
-              : 0,
-      } as DataState;
+          checkList.length === data.length ? 1 : state.checked.length ? 2 : 0,
+      } as DataState<T>;
     },
     {
+      items: data,
+      grouped: {},
+      groups: [],
       checked: [],
+      expanded: [],
       allChecked: 0,
     },
   );
 
+  const activeStickyIndexRef = useRef(0);
+  const stickyIndexes = useMemo<number[]>(
+    () =>
+      state.items
+        .map((hit, idx) => ("__GROUP__" in hit ? idx : undefined))
+        .filter(Boolean) as number[],
+    [state.items],
+  );
+  const isActiveSticky = (index: number) =>
+    activeStickyIndexRef.current === index;
+
+  const [hasActiveSticky, setHasActiveSticky] = useState(false);
+  const scrollerRef = useRef<HTMLDivElement>(null);
+  const virtualizer = useVirtualizer({
+    count: state.items.length,
+    getScrollElement: () => scrollerRef.current,
+    estimateSize: () => 32,
+    rangeExtractor: useCallback(
+      (range: Range) => {
+        activeStickyIndexRef.current =
+          [...stickyIndexes]
+            .reverse()
+            .find((index) => range.startIndex > index) ?? 0;
+
+        setHasActiveSticky(range.startIndex !== activeStickyIndexRef.current);
+
+        const next = new Set([
+          activeStickyIndexRef.current,
+          ...defaultRangeExtractor(range),
+        ]);
+
+        return [...next];
+      },
+      [stickyIndexes],
+    ),
+  });
+
   const virtualItems = virtualizer.getVirtualItems();
 
   const getData = useCallback(
     (index: number) => {
-      return data[index];
+      return state.items[index];
     },
-    [data],
+    [state.items],
   );
 
+  useEffect(() => {
+    dispatch({ type: "grouped", key: options.groupProperty });
+  }, [options.groupProperty]);
+
+  useEffect(() => {
+    dispatch({ type: "updateState", checked: options.checked ?? [] });
+  }, [options.checked]);
+
   return {
     scrollerRef,
     items: virtualItems,
     checkState: state,
     getData,
+    virtualizer,
+    hasActiveSticky,
+    isActiveSticky,
+    top: virtualizer.range?.startIndex,
     totalSize: virtualizer.getTotalSize,
     measureElement: virtualizer.measureElement,
+    toggleGroupExpand: (key: Key) => dispatch({ type: "groupExpand", key }),
+    toggleExpand: (key: Key) => dispatch({ type: "expand", key }),
     toggleChecked: (key: Key) => dispatch({ type: "check", key }),
     toggleAllChecked: () => dispatch({ type: "checkall" }),
   };