@dxos/react-ui-table 0.4.10-main.fa5a270 → 0.4.10-main.fd4f2a3

package/src/components/Table/TableBody.tsx

@@ -28,10 +28,15 @@ const TableBody = ({ rows }: TableBodyProps) => {
       {rows.map((row) => {
         const isCurrent = currentDatum === row.original;
         const isSelected = rowSelection?.[row.id];
+
+        const isPinned = row.getIsPinned();
+
+        const classNames = tbodyTr({ canBeCurrent, isPinned: isPinned !== false });
+
         return (
           <tr
             key={keyAccessor ? keyAccessor(row.original) : row.id}
-            className={tbodyTr({ canBeCurrent })}
+            className={classNames}
             {...(isCurrent && { 'aria-current': 'location' })}
             {...(isSelected && { 'aria-selected': 'true' })}
             {...(canBeCurrent && {

package/src/components/hooks/useColumnSorting.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type SortDirection, type Column } from '@tanstack/react-table';
+import { useState } from 'react';
+
+export const useColumnSorting = (column: Column<any>) => {
+  const [sortDirection, setSortDirection] = useState<SortDirection | false>(column.getIsSorted());
+  const [firstSort, setFirstSort] = useState<SortDirection | undefined>();
+
+  const canSort = column.getCanSort();
+
+  const updateColumnSort = (direction: SortDirection | false) => {
+    setSortDirection(direction);
+
+    switch (direction) {
+      case false:
+        column.clearSorting();
+        break;
+      case 'asc':
+        column.toggleSorting(false); // descending false
+        break;
+      case 'desc':
+        column.toggleSorting(true); // descending true
+        break;
+    }
+  };
+
+  // Whichever sort is explicitly set first, will be the first sort direction
+  // When toggling, we always go to the other direction, and then to unsorted.
+  const onToggleSort = () => {
+    if (sortDirection === false) {
+      return;
+    }
+
+    if (sortDirection === firstSort) {
+      updateColumnSort(firstSort === 'asc' ? 'desc' : 'asc');
+    } else {
+      updateColumnSort(false);
+    }
+  };
+
+  const onSelectSort = (direction: SortDirection) => {
+    setFirstSort(direction);
+    updateColumnSort(direction);
+  };
+
+  const onClearSort = () => {
+    updateColumnSort(false);
+  };
+
+  return { canSort, sortDirection, onSelectSort, onToggleSort, onClearSort };
+};

package/src/components/hooks/usePinLastRow.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Table } from '@tanstack/react-table';
+import { useEffect, useState } from 'react';
+
+export const usePinLastRow = (
+  pinLastRow: boolean | undefined,
+  table: Table<any>,
+  data: any,
+  getScrollElement?: () => Element | null,
+) => {
+  const [pinnedRowKey, setPinnedRowKey] = useState<string>();
+
+  useEffect(() => {
+    if (!pinLastRow) {
+      return;
+    }
+
+    const rows = table.getRowModel().rows;
+    const rowToPin = rows[rows.length - 1];
+    const rowId = rowToPin.id;
+
+    if (rowId === pinnedRowKey) {
+      return;
+    }
+
+    table.resetRowPinning();
+    rowToPin.pin('bottom');
+
+    const scrollElement = getScrollElement?.();
+    const isFirstRender = pinnedRowKey === undefined;
+
+    if (scrollElement && !isFirstRender) {
+      requestAnimationFrame(() => {
+        scrollElement.scrollTo({ top: scrollElement.scrollHeight });
+      });
+    }
+
+    setPinnedRowKey(rowId);
+  }, [pinLastRow, table, getScrollElement, pinnedRowKey, setPinnedRowKey, data]);
+};

package/src/components/schema/SchemaToTable.stories.tsx

@@ -0,0 +1,72 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import '@dxosTheme';
+
+import * as Arbitrary from '@effect/schema/Arbitrary';
+import * as S from '@effect/schema/Schema';
+import * as fc from 'fast-check';
+import React, { useRef } from 'react';
+
+import { DensityProvider } from '@dxos/react-ui';
+import { withTheme } from '@dxos/storybook-utils';
+
+import { schemaToColumnDefs } from './schemaToColumns';
+import { Table } from '../Table/Table';
+
+export default {
+  title: 'react-ui-table/SchemaTable',
+  args: {},
+  decorators: [
+    withTheme,
+    (Story: any) => (
+      <DensityProvider density='fine'>
+        <Story />
+      </DensityProvider>
+    ),
+  ],
+};
+
+const exampleSchema = S.struct({
+  field1: S.string,
+  field2: S.number,
+  field3: S.Date,
+  field4: S.optional(S.string.pipe(S.length(10))),
+  field5: S.optional(
+    S.struct({
+      innerField1: S.string,
+      innerField2: S.number,
+    }),
+  ),
+});
+
+type ExampleSchema = S.Schema.Type<typeof exampleSchema>;
+
+const columns = schemaToColumnDefs(exampleSchema);
+
+const exampleSchemaArbitrary = Arbitrary.make(exampleSchema)(fc);
+
+const items = fc.sample(exampleSchemaArbitrary, 10);
+
+export const SchemaTable = {
+  render: () => {
+    const containerRef = useRef<HTMLDivElement | null>(null);
+
+    return (
+      <div ref={containerRef} className='fixed inset-0 overflow-auto'>
+        <Table<ExampleSchema>
+          role='grid'
+          rowsSelectable='multi'
+          keyAccessor={(row) => JSON.stringify(row)}
+          columns={columns}
+          data={items}
+          fullWidth
+          stickyHeader
+          border
+          getScrollElement={() => containerRef.current}
+        />
+      </div>
+    );
+  },
+};

package/src/components/schema/schema.test.ts

@@ -0,0 +1,148 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as S from '@effect/schema/Schema';
+import { expect } from 'chai';
+
+import { describe, test } from '@dxos/test';
+
+import { classifySchemaProperties } from './schema';
+
+describe('schema->column-type', () => {
+  test('basic', () => {
+    const simpleSchema = S.struct({
+      field1: S.string,
+      field2: S.number,
+    });
+
+    const columns = classifySchemaProperties(simpleSchema);
+
+    expect(columns).to.deep.equal([
+      ['field1', 'string'],
+      ['field2', 'number'],
+    ]);
+  });
+
+  test('optional properties', () => {
+    const simpleSchema = S.struct({
+      field1: S.optional(S.string),
+      field2: S.optional(S.number),
+    });
+
+    const columns = classifySchemaProperties(simpleSchema);
+
+    expect(columns).to.deep.equal([
+      ['field1', 'string'],
+      ['field2', 'number'],
+    ]);
+  });
+
+  test('dates', () => {
+    const simpleSchema = S.struct({
+      field1: S.Date,
+      field2: S.optional(S.Date),
+    });
+
+    const columns = classifySchemaProperties(simpleSchema);
+
+    expect(columns).to.deep.equal([
+      ['field1', 'date'],
+      ['field2', 'date'],
+    ]);
+  });
+
+  test('Piped validators', () => {
+    const simpleSchema = S.struct({
+      name: S.optional(S.string.pipe(S.nonEmpty(), S.maxLength(10))),
+      age: S.number.pipe(S.negative()),
+    });
+
+    const columns = classifySchemaProperties(simpleSchema);
+
+    expect(columns).to.deep.equal([
+      ['name', 'string'],
+      ['age', 'number'],
+    ]);
+  });
+
+  test('nested schema', () => {
+    const simpleSchema = S.struct({
+      name: S.string,
+      nested: S.struct({
+        age: S.number,
+      }),
+      someUnion: S.union(S.string, S.number),
+    });
+
+    const columns = classifySchemaProperties(simpleSchema);
+
+    expect(columns).to.deep.equal([
+      ['name', 'string'],
+      ['nested.age', 'number'],
+      ['someUnion', 'display'],
+    ]);
+  });
+
+  test('deeply nested schema', () => {
+    const simpleSchema = S.struct({
+      name: S.string,
+      nested: S.struct({
+        age: S.number,
+        deeplyNested: S.struct({
+          height: S.number,
+        }),
+      }),
+    });
+
+    const columns = classifySchemaProperties(simpleSchema);
+
+    expect(columns).to.deep.equal([
+      ['name', 'string'],
+      ['nested.age', 'number'],
+      ['nested.deeplyNested.height', 'number'],
+    ]);
+  });
+
+  test('even more deeply nested schema with optionals', () => {
+    const simpleSchema = S.struct({
+      name: S.string,
+      nested: S.struct({
+        age: S.number,
+        deeplyNested: S.optional(
+          S.struct({
+            height: S.optional(S.number),
+          }),
+        ),
+      }),
+    });
+
+    const columns = classifySchemaProperties(simpleSchema);
+
+    expect(columns).to.deep.equal([
+      ['name', 'string'],
+      ['nested.age', 'number'],
+      ['nested.deeplyNested.height', 'number'],
+    ]);
+  });
+
+  test('multiple-nested schemata as sibblings', () => {
+    const simpleSchema = S.struct({
+      name: S.string,
+      nested: S.struct({
+        age: S.number,
+      }),
+      nested2: S.struct({
+        height: S.number,
+      }),
+    });
+
+    const columns = classifySchemaProperties(simpleSchema);
+
+    expect(columns).to.deep.equal([
+      ['name', 'string'],
+      ['nested.age', 'number'],
+      ['nested2.height', 'number'],
+    ]);
+  });
+});

package/src/components/schema/schema.ts

@@ -0,0 +1,96 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { AST } from '@effect/schema';
+import type * as S from '@effect/schema/Schema';
+
+import { type ColumnType } from '../../schema';
+
+export type ClassifiedColumnType = ColumnType | 'display';
+
+const isOptionalUnion = (prop: AST.PropertySignature) => AST.isUnion(prop.type) && prop.isOptional;
+
+const unwrapOptionProperty = (prop: AST.PropertySignature) => {
+  if (!isOptionalUnion(prop)) {
+    throw new Error('Not an optional property');
+  }
+
+  if (!AST.isUnion(prop.type)) {
+    throw new Error('Not a union type');
+  }
+
+  const [type, _undefinedCase] = prop.type.types;
+
+  return type;
+};
+
+const typeToColumn = (type: AST.AST): ClassifiedColumnType => {
+  if (AST.isStringKeyword(type)) {
+    return 'string';
+  } else if (AST.isNumberKeyword(type)) {
+    return 'number';
+  } else if (AST.isBooleanKeyword(type)) {
+    return 'boolean';
+  }
+
+  if (AST.isRefinement(type)) {
+    return typeToColumn(type.from);
+  }
+
+  // TODO(zan): How should we be thinking about transformations?
+  // - Which of these are we storing in the database?
+  // - For types that aren't the 'DateFromString' transformation, should we be using the 'from' or 'to' type?
+
+  if (AST.isTransform(type)) {
+    const identifier = AST.getIdentifierAnnotation(type);
+
+    if (identifier._tag === 'Some') {
+      if (identifier.value === 'DateFromString') {
+        return 'date';
+      }
+    }
+  }
+
+  return 'display';
+};
+
+const propertyToColumn = (property: AST.PropertySignature): ClassifiedColumnType => {
+  let type = property.type;
+
+  if (property.isOptional) {
+    type = unwrapOptionProperty(property);
+  }
+
+  return typeToColumn(type);
+};
+
+const isStruct = (node: AST.AST) => AST.isTypeLiteral(node);
+
+export const classifySchemaProperties = (schema: S.Schema<any, any>) => {
+  const recurse = (node: AST.AST, path: string[], acc: [string, ClassifiedColumnType][]) => {
+    const properties = AST.getPropertySignatures(node);
+
+    properties.forEach((prop) => {
+      const propName = prop.name.toString();
+
+      if (prop.isOptional) {
+        const unwrappedAst = unwrapOptionProperty(prop);
+
+        if (isStruct(unwrappedAst)) {
+          return recurse(unwrappedAst, [...path, propName], acc);
+        }
+      }
+
+      if (isStruct(prop.type)) {
+        recurse(prop.type, [...path, propName], acc);
+      } else {
+        acc.push([path.concat(propName).join('.'), propertyToColumn(prop)]);
+      }
+    });
+
+    return acc;
+  };
+
+  return recurse(schema.ast, [], []);
+};

package/src/components/schema/schemaToColumns.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import type * as S from '@effect/schema/Schema';
+import { type ColumnDef } from '@tanstack/react-table';
+
+import { classifySchemaProperties } from './schema';
+import { createColumnBuilder } from '../../helpers';
+
+export const schemaToColumnDefs = <T>(schema: S.Schema<T, any>): ColumnDef<T, any>[] => {
+  const classified = classifySchemaProperties(schema);
+
+  const { helper, builder } = createColumnBuilder<T>();
+
+  return classified.map(([name, type]) => {
+    const propertyKey = name.toString();
+
+    let column: Partial<ColumnDef<any, any>> | undefined;
+
+    switch (type) {
+      case 'string': {
+        column = builder.string({ label: propertyKey });
+        break;
+      }
+      case 'number': {
+        column = builder.number({ label: propertyKey });
+        break;
+      }
+      case 'boolean': {
+        column = builder.switch({ label: propertyKey });
+        break;
+      }
+      case 'date': {
+        column = builder.date({ label: propertyKey });
+        break;
+      }
+      case 'display': {
+        column = builder.display({ label: propertyKey, id: propertyKey });
+        break;
+      }
+    }
+
+    if (column === undefined) {
+      throw new Error(`Unhandled column type: ${type}`);
+    }
+
+    return helper.accessor(propertyKey as any, column);
+  });
+};

package/src/helpers.tsx

@@ -340,7 +340,7 @@ export class ColumnBuilder<TData extends RowData> {
         ...props.meta,
         onUpdate,
         digits,
-        header: { classNames: 'text-end', ...props.meta?.header },
+        header: { ...props.meta?.header },
         cell: { ...props.meta?.cell, classNames },
       },
     };
@@ -498,4 +498,26 @@ export class ColumnBuilder<TData extends RowData> {
       ...props,
     };
   }
+
+  /**
+   * This display column type is for nested/unhandled data to appear as JSON.
+   */
+  display({ label, classNames, ...props }: KeyColumnOptions<TData> = {}): Partial<ColumnDef<TData, PublicKey>> {
+    return {
+      size: 120,
+      minSize: 120,
+      header: (cell) => label ?? cell.header.id,
+      cell: (cell) => {
+        const value = cell.getValue();
+
+        return (
+          <div className='overflow-scroll'>
+            <code className='text-xs'>{JSON.stringify(value)}</code>
+          </div>
+        );
+      },
+      ...props,
+      meta: { ...props.meta, cell: { ...props.meta?.cell, classNames: ['font-mono', textPadding, classNames] } },
+    };
+  }
 }

package/src/theme.ts

@@ -75,13 +75,14 @@ export const theadResizeRoot: ComponentFunction<{ isResizing: boolean }> = ({ is
 export type TbodyStyleProps = Partial<TableContextValue<any>>;
 export const tbodyRoot: ComponentFunction<TbodyStyleProps> = (_props, ...etc) => mx(...etc);
 
-export type TbodyTrStyleProps = Partial<{ canBeCurrent?: boolean }>;
-export const tbodyTr: ComponentFunction<TbodyTrStyleProps> = ({ canBeCurrent }, ...etc) =>
+export type TbodyTrStyleProps = Partial<{ canBeCurrent?: boolean; isPinned?: boolean }>;
+export const tbodyTr: ComponentFunction<TbodyTrStyleProps> = ({ canBeCurrent, isPinned }, ...etc) =>
   mx(
     'group',
     canBeCurrent ? ghostSelectedCurrent : ghostSelected,
     canBeCurrent && focusRing,
     canBeCurrent && 'cursor-pointer rounded',
+    isPinned && 'sticky z-1 bottom-[-1px] base-surface',
     ...etc,
   );
 

package/dist/types/src/components/SortButton.d.ts

@@ -1,8 +0,0 @@
-import { type SortDirection } from '@tanstack/react-table';
-type SortButtonProps = {
-    sortDirection: false | SortDirection;
-    onClick: (e: any) => void;
-};
-export declare const SortButton: ({ sortDirection, onClick }: SortButtonProps) => JSX.Element;
-export {};
-//# sourceMappingURL=SortButton.d.ts.map

package/dist/types/src/components/SortButton.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SortButton.d.ts","sourceRoot":"","sources":["../../../../src/components/SortButton.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAM3D,KAAK,eAAe,GAAG;IAAE,aAAa,EAAE,KAAK,GAAG,aAAa,CAAC;IAAC,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,CAAA;CAAE,CAAC;AAE3F,eAAO,MAAM,UAAU,+BAAgC,eAAe,gBAoBrE,CAAC"}

package/src/components/SortButton.tsx

@@ -1,34 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { CaretUpDown, SortAscending, SortDescending } from '@phosphor-icons/react';
-import { type SortDirection } from '@tanstack/react-table';
-import React, { type ReactElement } from 'react';
-
-import { Button } from '@dxos/react-ui';
-import { getSize } from '@dxos/react-ui-theme';
-
-type SortButtonProps = { sortDirection: false | SortDirection; onClick: (e: any) => void };
-
-export const SortButton = ({ sortDirection, onClick }: SortButtonProps) => {
-  let icon: ReactElement;
-  const size = getSize(4);
-
-  switch (sortDirection) {
-    case 'asc':
-      icon = <SortAscending className={size} />;
-      break;
-    case 'desc':
-      icon = <SortDescending className={size} />;
-      break;
-    default:
-      icon = <CaretUpDown className={size} />;
-  }
-
-  return (
-    <Button variant='ghost' onClick={onClick}>
-      {icon}
-    </Button>
-  );
-};