@dxos/react-ui-table 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/hooks/useTableModel.ts

@@ -2,58 +2,65 @@
 // Copyright 2024 DXOS.org
 //
 
-import { effect } from '@preact/signals-core';
-import orderBy from 'lodash.orderby';
-import { useEffect, useMemo, useState } from 'react';
+import { RegistryContext } from '@effect-atom/atom-react';
+import { useContext, useEffect, useMemo, useState } from 'react';
 
-import { type JsonSchemaType } from '@dxos/echo-schema';
-import { type Live } from '@dxos/live-object';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
+import { type Database, Obj } from '@dxos/echo';
 import { useSelected, useSelectionActions } from '@dxos/react-ui-attention';
-import { type DataType, type ProjectionModel } from '@dxos/schema';
+import { type ProjectionModel } from '@dxos/schema';
 import { isNonNullable } from '@dxos/util';
 
-import { TableModel, type TableModelProps, type TableRow, type TableRowAction } from '../model';
+import {
+  TableModel,
+  type TableModelProps,
+  type TableRow,
+  type TableRowAction,
+  createEchoChangeCallback,
+} from '../model';
+import { type Table } from '../types';
 
-export type UseTableModelParams<T extends TableRow = TableRow> = {
-  view?: DataType.View;
-  schema?: JsonSchemaType;
+export type UseTableModelProps<T extends TableRow = TableRow> = {
+  object?: Table.Table;
   projection?: ProjectionModel;
-  rows?: Live<T>[];
+  db?: Database.Database;
+  rows?: T[];
   rowActions?: TableRowAction[];
   onSelectionChanged?: (selection: string[]) => void;
   onRowAction?: (actionId: string, data: T) => void;
 } & Pick<
   TableModelProps<T>,
-  'features' | 'onInsertRow' | 'onDeleteRows' | 'onDeleteColumn' | 'onCellUpdate' | 'onRowOrderChange'
+  'features' | 'onInsertRow' | 'onDeleteRows' | 'onColumnDelete' | 'onCellUpdate' | 'onRowOrderChange'
 >;
 
 export const useTableModel = <T extends TableRow = TableRow>({
-  view,
-  schema,
+  object,
   projection,
+  db,
   rows,
   rowActions,
   features,
   onSelectionChanged,
   onRowAction,
   ...props
-}: UseTableModelParams<T>): TableModel<T> | undefined => {
-  const selected = useSelected(view && fullyQualifiedId(view), 'multi');
-  const initialSelection = useMemo(() => selected, [view]);
+}: UseTableModelProps<T>): TableModel<T> | undefined => {
+  const registry = useContext(RegistryContext);
+  const selected = useSelected(object && Obj.getURI(object), 'multi');
+  const initialSelection = useMemo(() => selected, [object]);
 
   const [model, setModel] = useState<TableModel<T>>();
   useEffect(() => {
-    if (!view || !schema) {
+    if (!object || !projection) {
       return;
     }
 
     let model: TableModel<T> | undefined;
     const t = setTimeout(async () => {
       model = new TableModel<T>({
-        view,
-        schema,
+        registry,
+        object,
         projection,
+        db,
+        change: createEchoChangeCallback<T>(object),
         features,
         rowActions,
         initialSelection,
@@ -68,18 +75,13 @@ export const useTableModel = <T extends TableRow = TableRow>({
       clearTimeout(t);
       void model?.close();
     };
-  }, [view, schema, projection, features, rowActions, initialSelection]); // TODO(burdon): Trigger if callbacks change?
+    // TODO(burdon): Trigger if callbacks change?
+  }, [registry, object, projection, features, rowActions, initialSelection]);
 
-  // Update data.
+  // Update data when rows change.
   useEffect(() => {
-    if (rows) {
-      // TODO(ZaymonFC): Remove this workaround once unstable query ordering issue is resolved
-      /*
-       * Sort all objects by string id field as a temporary workaround for query ordering issues
-       * Reference: https://github.com/dxos/dxos/pull/9409
-       */
-      const sortedRows = orderBy(rows, [(row) => String(row.id)], ['asc']);
-      model?.setRows(sortedRows);
+    if (rows && model) {
+      model.setRows(rows);
     }
   }, [model, rows]);
 
@@ -90,8 +92,8 @@ export const useTableModel = <T extends TableRow = TableRow>({
       return;
     }
 
-    const unsubscribe = effect(() => {
-      const selectedItems = [...model.selection.selection.value];
+    const unsubscribe = registry.subscribe(model.selection.selectionAtom, () => {
+      const selectedItems = [...model.selection.selection];
       multiSelect(selectedItems);
       onSelectionChanged?.(selectedItems);
     });
@@ -101,7 +103,7 @@ export const useTableModel = <T extends TableRow = TableRow>({
       clear();
       unsubscribe();
     };
-  }, [model, onSelectionChanged]);
+  }, [registry, model, onSelectionChanged]);
 
   return model;
 };

package/src/index.ts

@@ -2,11 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { translations } from './translations';
-
 export * from './components';
 export * from './hooks';
 export * from './model';
 export * from './util';
-
-export { translations };

package/src/model/modal-controller.ts

@@ -2,35 +2,36 @@
 // Copyright 2024 DXOS.org
 //
 
-import { signal } from '@preact/signals-core';
+import { Atom, type Registry } from '@effect-atom/atom-react';
 import { type MutableRefObject, type RefObject } from 'react';
 
-import { type Live } from '@dxos/live-object';
-import { log } from '@dxos/log';
-
 export type ColumnSettingsMode = { type: 'create' } | { type: 'edit'; fieldId: string };
 
 export type ModalState =
   | { type: 'row'; rowIndex: number }
   | { type: 'column'; fieldId: string }
   | { type: 'refPanel'; targetId: string; typename: string }
-  | {
-      type: 'createRefPanel';
-      typename: string;
-      initialValues?: Record<string, string>;
-      onCreate?: (obj: Live<any>) => void;
-    }
   | { type: 'columnSettings'; mode: ColumnSettingsMode }
   | { type: 'closed' };
 
 export class ModalController {
-  private readonly _state = signal<ModalState>({ type: 'closed' });
+  private readonly _registry: Registry.Registry;
+  private readonly _state: Atom.Writable<ModalState>;
   private readonly _triggerRef: MutableRefObject<HTMLElement> = { current: null as unknown as HTMLElement };
 
-  public get state() {
+  constructor(registry: Registry.Registry) {
+    this._registry = registry;
+    this._state = Atom.make<ModalState>({ type: 'closed' });
+  }
+
+  public get state(): Atom.Atom<ModalState> {
     return this._state;
   }
 
+  public get stateValue(): ModalState {
+    return this._registry.get(this._state);
+  }
+
   public get trigger() {
     return this._triggerRef as RefObject<HTMLButtonElement>;
   }
@@ -40,54 +41,36 @@ export class ModalController {
   };
 
   public showRowMenu = (rowIndex: number) => {
-    this._state.value = { type: 'row', rowIndex };
+    this._registry.set(this._state, { type: 'row', rowIndex });
   };
 
   public showColumnMenu = (fieldId: string) => {
-    this._state.value = { type: 'column', fieldId };
+    this._registry.set(this._state, { type: 'column', fieldId });
   };
 
   public showColumnCreator = () => {
-    this._state.value = { type: 'columnSettings', mode: { type: 'create' } };
+    this._registry.set(this._state, { type: 'columnSettings', mode: { type: 'create' } });
   };
 
   public showReferencePanel = (targetId: string, schemaId: string) => {
-    this._state.value = { type: 'refPanel', targetId, typename: schemaId };
+    this._registry.set(this._state, { type: 'refPanel', targetId, typename: schemaId });
   };
 
   public openColumnSettings = () => {
-    if (this._state.value.type === 'column') {
-      const fieldId = this._state.value.fieldId;
+    const currentState = this._registry.get(this._state);
+    if (currentState.type === 'column') {
+      const fieldId = currentState.fieldId;
       // Queue next render to let the column action modal close completely.
       requestAnimationFrame(() => {
-        this._state.value = {
+        this._registry.set(this._state, {
           type: 'columnSettings',
           mode: { type: 'edit', fieldId },
-        };
+        });
       });
     }
   };
 
-  public openCreateRef = (
-    typename: string,
-    anchorCell: Element | null,
-    initialValues?: Record<string, string>,
-    onCreate?: (obj: Live<any>) => void,
-  ) => {
-    if (anchorCell) {
-      this._triggerRef.current = anchorCell as HTMLElement;
-      this._state.value = {
-        type: 'createRefPanel',
-        typename,
-        initialValues,
-        onCreate,
-      };
-    } else {
-      log.warn('anchor cell not found while creating new ref');
-    }
-  };
-
   public close = () => {
-    this._state.value = { type: 'closed' };
+    this._registry.set(this._state, { type: 'closed' });
   };
 }

package/src/model/selection-model.ts

@@ -2,90 +2,120 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type ReadonlySignal, type Signal, computed, effect, signal } from '@preact/signals-core';
+import { Atom, type Registry } from '@effect-atom/atom-react';
 
 import { Resource } from '@dxos/context';
 
-import { touch } from '../util';
-
 import { type TableRow } from './table-model';
 
 export type SelectionMode = 'single' | 'multiple';
 
 export class SelectionModel<T extends TableRow> extends Resource {
-  private readonly _selection: Signal<Set<string>>;
+  private readonly _registry: Registry.Registry;
+  private readonly _rows: Atom.Atom<T[]>;
+  private readonly _selection: Atom.Writable<Set<string>>;
+  private readonly _validSelectedIds: Atom.Atom<Set<string>>;
+  private readonly _hasSelection: Atom.Atom<boolean>;
+  private readonly _allSelected: Atom.Atom<boolean>;
+  private readonly _selectionMode: SelectionMode;
+  private readonly _onSelectionChanged?: () => void;
 
-  private readonly _validSelectedIds = computed<Set<string>>(() => {
-    const rows = this._rows.value;
-    if (!rows) {
-      return new Set<string>();
-    }
+  constructor(
+    registry: Registry.Registry,
+    rows: Atom.Atom<T[]>,
+    selectionMode: SelectionMode,
+    initialSelection: string[],
+    onSelectionChanged?: () => void,
+  ) {
+    super();
+    this._registry = registry;
+    this._rows = rows;
+    this._selectionMode = selectionMode;
+    this._onSelectionChanged = onSelectionChanged;
 
-    const validIds = new Set(rows.map((row) => row.id));
-    return new Set([...this._selection.value].filter((id) => validIds.has(id)));
-  });
+    this._selection = Atom.make<Set<string>>(new Set(initialSelection));
 
-  private readonly _hasSelection = computed<boolean>(() => this._validSelectedIds.value.size > 0);
+    this._validSelectedIds = Atom.make((get) => {
+      const rows = get(this._rows);
+      if (!rows) {
+        return new Set<string>();
+      }
 
-  private readonly _allSelected = computed<boolean>(() => {
-    const rows = this._rows.value;
-    if (rows.length === 0) {
-      return false;
-    }
+      const validIds = new Set(rows.map((row) => row.id));
+      const selection = get(this._selection);
+      return new Set([...selection].filter((id) => validIds.has(id)));
+    });
 
-    return rows.every((row) => this._selection.value.has(row.id));
-  });
+    this._hasSelection = Atom.make((get) => get(this._validSelectedIds).size > 0);
 
-  constructor(
-    private readonly _rows: ReadonlySignal<T[]>,
-    private readonly _selectionMode: SelectionMode,
-    private readonly _initialSelection: string[],
-    private readonly _onSelectionChanged?: () => void,
-  ) {
-    super();
-    this._selection = signal(new Set(this._initialSelection));
+    this._allSelected = Atom.make((get) => {
+      const rows = get(this._rows);
+      if (rows.length === 0) {
+        return false;
+      }
+
+      const selection = get(this._selection);
+      return rows.every((row) => selection.has(row.id));
+    });
   }
 
   protected override async _open(): Promise<void> {
-    const selectionWatcher = effect(() => {
-      touch(this._selection.value);
+    const selectionUnsubscribe = this._registry.subscribe(this._selection, () => {
       this._onSelectionChanged?.();
     });
-    this._ctx.onDispose(selectionWatcher);
+    this._ctx.onDispose(selectionUnsubscribe);
   }
 
   //
   // Getters
   //
 
-  public get selection(): ReadonlySignal<Set<string>> {
+  /** Get the selection atom for reactive access. */
+  public get selectionAtom(): Atom.Atom<Set<string>> {
     return this._selection;
   }
 
-  public get hasSelection(): ReadonlySignal<boolean> {
+  /** Get the current selection value. */
+  public get selection(): Set<string> {
+    return this._registry.get(this._selection);
+  }
+
+  /** Get the hasSelection atom for reactive access. */
+  public get hasSelectionAtom(): Atom.Atom<boolean> {
     return this._hasSelection;
   }
 
-  public get allRowsSeleted(): ReadonlySignal<boolean> {
+  /** Check if there is any selection. */
+  public get hasSelection(): boolean {
+    return this._registry.get(this._hasSelection);
+  }
+
+  /** Get the allRowsSelected atom for reactive access. */
+  public get allRowsSelectedAtom(): Atom.Atom<boolean> {
     return this._allSelected;
   }
 
+  /** Check if all rows are selected. */
+  public get allRowsSelected(): boolean {
+    return this._registry.get(this._allSelected);
+  }
+
   public get selectionMode(): SelectionMode {
     return this._selectionMode;
   }
 
   public getSelectedRows = (): T[] => {
-    const selectedIds = this._validSelectedIds.value;
-    return this._rows.value.filter((row) => selectedIds.has(row.id));
+    const selectedIds = this._registry.get(this._validSelectedIds);
+    return this._registry.get(this._rows).filter((row) => selectedIds.has(row.id));
   };
 
   public isRowIndexSelected = (rowIndex: number): boolean => {
-    const row = this._rows.value[rowIndex];
-    return this._selection.value.has(row.id);
+    const row = this._registry.get(this._rows)[rowIndex];
+    return this._registry.get(this._selection).has(row.id);
   };
 
   public isObjectSelected = (object: T): boolean => {
-    return this._selection.value.has(object.id);
+    return this._registry.get(this._selection).has(object.id);
   };
 
   //
@@ -93,8 +123,9 @@ export class SelectionModel<T extends TableRow> extends Resource {
   //
 
   public toggleSelectionForRowIndex = (rowIndex: number): void => {
-    const row = this._rows.value[rowIndex];
-    const newSelection = new Set(this._selection.value);
+    const row = this._registry.get(this._rows)[rowIndex];
+    const currentSelection = this._registry.get(this._selection);
+    const newSelection = new Set(currentSelection);
 
     if (newSelection.has(row.id)) {
       newSelection.delete(row.id);
@@ -105,17 +136,17 @@ export class SelectionModel<T extends TableRow> extends Resource {
       newSelection.add(row.id);
     }
 
-    this._selection.value = newSelection;
+    this._registry.set(this._selection, newSelection);
   };
 
   public setSelection = (mode: 'all' | 'none'): void => {
     switch (mode) {
       case 'all': {
-        this._selection.value = new Set(this._rows.value.map((row) => row.id));
+        this._registry.set(this._selection, new Set(this._registry.get(this._rows).map((row) => row.id)));
         break;
       }
       case 'none': {
-        this._selection.value = new Set();
+        this._registry.set(this._selection, new Set());
         break;
       }
     }

package/src/model/table-model.test.ts

@@ -2,37 +2,41 @@
 // Copyright 2024 DXOS.org
 //
 
-import { computed } from '@preact/signals-core';
-import { Schema } from 'effect';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { Registry } from '@effect-atom/atom-react';
+import * as Schema from 'effect/Schema';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Obj } from '@dxos/echo';
-import { TypedObject } from '@dxos/echo-schema';
-import { updateCounter } from '@dxos/echo-schema/testing';
-import { registerSignalsRuntime } from '@dxos/echo-signals';
-import { live } from '@dxos/live-object';
-import { createEchoSchema } from '@dxos/live-object/testing';
-import { createView } from '@dxos/schema';
+import { DXN, Filter, JsonSchema, Query, Type } from '@dxos/echo';
+import { createEchoSchema } from '@dxos/echo/testing';
+import { ProjectionModel, ViewModel, createDirectChangeCallback } from '@dxos/schema';
 
-import { TableView } from '../types';
-
-import { TableModel, type TableModelProps } from './table-model';
+import { Table } from '../types';
+import {
+  TableModel,
+  type TableModelProps,
+  createDirectChangeCallback as createTableDirectChangeCallback,
+} from './table-model';
 
 // TODO(burdon): Tests are disabled in project.json since they bring in plugin deps.
 //  Restore once factored out into react-ui-table.
 
-registerSignalsRuntime();
-
 describe('TableModel', () => {
   let updateCount = 0;
-  let model: TableModel;
+  let model: any;
+  let registry: Registry.Registry;
 
   beforeEach(async () => {
     updateCount = 0;
-    model = createTableModel({
+    registry = Registry.make();
+    model = createTableModel(registry, {
       onCellUpdate: () => updateCount++,
     });
     await model.open();
+    model.setRows([
+      { id: '1', title: 'Test', completed: false },
+      { id: '2', title: 'Test 2', completed: true },
+      { id: '3', title: 'Test 3', completed: false },
+    ]);
   });
 
   afterEach(async () => {
@@ -40,75 +44,101 @@ describe('TableModel', () => {
   });
 
   describe('methods', () => {
-    it('should pin a row', () => {
+    test('should pin a row', () => {
       model.pinRow(1, 'top');
       expect(model.pinnedRows.top).toContain(1);
     });
 
-    it('should unpin a row', () => {
+    test('should unpin a row', () => {
       model.pinRow(1, 'top');
       model.unpinRow(1);
       expect(model.pinnedRows.top).not.toContain(1);
     });
 
-    it('should toggle row selection', () => {
+    test('should toggle row selection', () => {
       model.selection.toggleSelectionForRowIndex(2);
-      expect(model.selection.hasSelection.value).toBe(true);
+      expect(model.selection.hasSelection).toBe(true);
     });
 
-    it('should deselect a row', () => {
+    test('should deselect a row', () => {
       model.selection.toggleSelectionForRowIndex(2);
       model.selection.toggleSelectionForRowIndex(2);
-      expect(model.selection.hasSelection.value).toBe(false);
+      expect(model.selection.hasSelection).toBe(false);
     });
 
-    it('should bulk select rows', () => {
+    test('should bulk select rows', () => {
       model.selection.setSelection('all');
-      expect(model.selection.allRowsSeleted.value).toBe(true);
+      expect(model.selection.allRowsSelected).toBe(true);
       model.selection.setSelection('none');
-      expect(model.selection.hasSelection.value).toBe(false);
+      expect(model.selection.hasSelection).toBe(false);
     });
   });
 
   describe('reactivity', () => {
-    it('pure signals should nest', () => {
-      const signal$ = live({ arr: [{ thingInside: 1 }, { thingInside: 2 }] });
-
-      const computed$ = computed(() => {
-        return signal$.arr.map((row) =>
-          computed(() => {
-            return row.thingInside;
-          }),
-        );
-      });
-
-      using outerCounter = updateCounter(() => {
-        computed$.value.map((c) => c.value);
-      });
-
-      using innerCounter = updateCounter(() => {
-        computed$.value[0].value;
-      });
+    test('rows should update when setRows is called', () => {
+      model.setRows([{ id: '4', title: 'Test 4', completed: false }]);
+      expect(model.getRows()).toHaveLength(1);
+      expect(model.getRows()[0].id).toBe('4');
+
+      model.setRows([
+        { id: '5', title: 'Test 5', completed: false },
+        { id: '6', title: 'Test 6', completed: true },
+      ]);
+      expect(model.getRows()).toHaveLength(2);
+      expect(model.getRows()[0].id).toBe('5');
+      expect(model.getRows()[1].id).toBe('6');
+    });
 
-      expect(computed$.value.map((v) => v.value)).toEqual([1, 2]);
+    test('selection should update when toggled', () => {
+      model.selection.toggleSelectionForRowIndex(0);
+      expect(model.selection.hasSelection).toBe(true);
+      expect(model.selection.selection.size).toBe(1);
 
-      signal$.arr[0].thingInside = 3;
+      model.selection.toggleSelectionForRowIndex(0);
+      expect(model.selection.hasSelection).toBe(false);
+      expect(model.selection.selection.size).toBe(0);
+    });
 
-      expect(computed$.value.map((v) => v.value)).toEqual([3, 2]);
-      expect(outerCounter.count).toBe(1);
-      expect(innerCounter.count).toBe(1);
+    test('derived atoms should reflect current state', () => {
+      // Set initial rows.
+      model.setRows([
+        { id: '1', title: 'Zebra', completed: false },
+        { id: '2', title: 'Apple', completed: true },
+        { id: '3', title: 'Mango', completed: false },
+      ]);
+
+      // Verify rows are accessible.
+      const rows = model.getRows();
+      expect(rows).toHaveLength(3);
+      expect(rows[0].id).toBeDefined();
     });
   });
 });
 
-class Test extends TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })({
+const Test = Schema.Struct({
   title: Schema.String,
   completed: Schema.Boolean,
-}) {}
+}).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
 
-const createTableModel = (props: Partial<TableModelProps> = {}): TableModel => {
-  const schema = createEchoSchema(Test);
-  const table = Obj.make(TableView, { sizes: {} });
-  const view = createView({ typename: schema.typename, jsonSchema: schema.jsonSchema, presentation: table });
-  return new TableModel({ view, schema: schema.jsonSchema, ...props });
+const createTableModel = (registry: Registry.Registry, props: Partial<TableModelProps> = {}): TableModel => {
+  const schema = createEchoSchema(Type.getSchema(Test));
+  const view = ViewModel.make({
+    query: Query.select(Filter.type(schema)),
+    jsonSchema: schema.jsonSchema,
+  });
+  const object = Table.make({ view });
+  const projection = new ProjectionModel({
+    registry,
+    view,
+    baseSchema: schema.jsonSchema,
+    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(Type.getSchema(schema))),
+  });
+  projection.normalizeView();
+  return new TableModel({
+    registry,
+    object,
+    projection,
+    change: createTableDirectChangeCallback(object),
+    ...props,
+  });
 };