@dxos/react-ui-table 0.8.4-main.67995b8 → 0.8.4-main.70d3990

package/src/components/TableToolbar/TableToolbar.tsx

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
+import { Atom } from '@effect-atom/atom-react';
 import React, { useMemo } from 'react';
 
 import { live } from '@dxos/live-object';
@@ -11,14 +11,14 @@ import {
   type ActionGraphEdges,
   type ActionGraphNodes,
   type ActionGraphProps,
-  createGapSeparator,
-  createMenuAction,
   type MenuAction,
   MenuProvider,
   ToolbarMenu,
+  createGapSeparator,
+  createMenuAction,
   useMenuActions,
 } from '@dxos/react-ui-menu';
-import { rxFromSignal } from '@dxos/react-ui-menu';
+import { atomFromSignal } from '@dxos/react-ui-menu';
 
 import { translationKey } from '../../translations';
 
@@ -30,12 +30,14 @@ export type TableToolbarActionType = 'add-row' | 'comment' | 'save-view';
 
 type TableToolbarState = Partial<{ viewDirty: boolean }>;
 
+// TODO(burdon): Radix style layout.
+
 export type TableToolbarProps = ThemedClassName<
   TableToolbarState & {
     onAdd: () => void;
     onSave: () => void;
     attendableId?: string;
-    customActions?: Rx.Rx<ActionGraphProps>;
+    customActions?: Atom.Atom<ActionGraphProps>;
   }
 >;
 
@@ -46,33 +48,41 @@ const createTableToolbarActions = ({
   customActions,
 }: {
   state: TableToolbarState;
-  onAdd: () => void;
-  onSave: () => void;
-  customActions?: Rx.Rx<ActionGraphProps>;
+  onAdd?: () => void;
+  onSave?: () => void;
+  customActions?: Atom.Atom<ActionGraphProps>;
 }) =>
-  Rx.make((get) => {
-    const add = createMenuAction<TableToolbarActionProperties>('add-row', onAdd, {
-      type: 'add-row' as const,
-      icon: 'ph--plus--regular',
-      label: ['add row', { ns: translationKey }],
-      testId: 'table.toolbar.add-row',
-    });
-    const save = createMenuAction<TableToolbarActionProperties>('save-view', onSave, {
-      type: 'save-view' as const,
-      icon: 'ph--floppy-disk--regular',
-      label: ['save view label', { ns: translationKey }],
-      testId: 'table.toolbar.save-view',
-      iconOnly: false,
-      hidden: get(rxFromSignal(() => !state.viewDirty)),
-    });
+  Atom.make((get) => {
+    const nodes: ActionGraphNodes = [];
+    if (onAdd) {
+      const add = createMenuAction<TableToolbarActionProperties>('add-row', onAdd, {
+        type: 'add-row' as const,
+        icon: 'ph--plus--regular',
+        label: ['add row label', { ns: translationKey }],
+        testId: 'table.toolbar.add-row',
+      });
+      nodes.push(add);
+    }
+    if (onSave) {
+      const save = createMenuAction<TableToolbarActionProperties>('save-view', onSave, {
+        type: 'save-view' as const,
+        icon: 'ph--floppy-disk--regular',
+        label: ['save view label', { ns: translationKey }],
+        testId: 'table.toolbar.save-view',
+        iconOnly: false,
+        hidden: get(atomFromSignal(() => !state.viewDirty)),
+      });
+      nodes.push(save);
+    }
     const gap = createGapSeparator();
-    const nodes: ActionGraphNodes = [add, save, ...gap.nodes];
+    nodes.push(...gap.nodes);
     const edges: ActionGraphEdges = nodes.map(({ id: target }) => ({ source: 'root', target }));
     if (customActions) {
       const custom = get(customActions);
       nodes.push(...custom.nodes);
       edges.push(...custom.edges);
     }
+
     return {
       nodes,
       edges,

package/src/components/testing.ts

@@ -2,16 +2,16 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 import { useEffect } from 'react';
 
-import { FormatEnum, ObjectId, setValue, TypedObject, TypeEnum } from '@dxos/echo-schema';
+import { Format } from '@dxos/echo';
+import { TypeEnum, TypedObject, setValue } from '@dxos/echo/internal';
 import { live } from '@dxos/live-object';
 import { faker } from '@dxos/random';
 import { type ProjectionModel } from '@dxos/schema';
 
 export const TestSchema = TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })({
-  id: ObjectId,
   name: Schema.optional(Schema.String),
   age: Schema.optional(Schema.Number),
   active: Schema.optional(Schema.Boolean),
@@ -88,7 +88,7 @@ export const useSimulator = ({ items, projection, insertInterval, updateInterval
 
         if (format) {
           switch (format) {
-            case FormatEnum.Currency: {
+            case Format.TypeFormat.Currency: {
               item[path] = Math.floor(Math.random() * 1000);
               break;
             }

package/src/hooks/index.ts

@@ -2,5 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './useTableModel';
 export * from './useAddRow';
+export * from './useProjectionModel';
+export * from './useTableModel';

package/src/hooks/useAddRow.ts

@@ -2,12 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
+import type * as Schema from 'effect/Schema';
 import { useCallback } from 'react';
 
 import { type Space } from '@dxos/client/echo';
 import { Obj } from '@dxos/echo';
 
+import { type InsertRowResult } from '../model';
+
 export type UseAddRowParams = {
   space?: Space;
   schema?: Schema.Schema.AnyNoContext;
@@ -20,16 +22,16 @@ export type UseAddRowParams = {
  */
 export const useAddRow = ({ space, schema }: UseAddRowParams) => {
   return useCallback(
-    (data?: any) => {
+    (data?: any): InsertRowResult => {
       if (space && schema) {
         try {
           space.db.add(Obj.make(schema, data ?? {}));
-          return true;
+          return 'final';
         } catch (error) {
-          return false;
+          return 'draft';
         }
       }
-      return false;
+      return 'final';
     },
     [space, schema],
   );

package/src/hooks/useProjectionModel.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { Type } from '@dxos/echo';
+import { ProjectionModel } from '@dxos/schema';
+
+import { type Table } from '../types';
+
+export const useProjectionModel = <S extends Type.Entity.Any>(schema: S | undefined, table: Table.Table | undefined) =>
+  useMemo(() => {
+    if (schema && table?.view.target?.projection) {
+      const projection = new ProjectionModel(Type.toJsonSchema(schema), table.view.target.projection);
+      projection.normalizeView();
+      return projection;
+    }
+  }, [schema, table?.view.target?.projection]);

package/src/hooks/useTableModel.ts

@@ -6,18 +6,17 @@ import { effect } from '@preact/signals-core';
 import orderBy from 'lodash.orderby';
 import { useEffect, useMemo, useState } from 'react';
 
-import { type JsonSchemaType } from '@dxos/echo-schema';
+import { Obj } from '@dxos/echo';
 import { type Live } from '@dxos/live-object';
-import { fullyQualifiedId } from '@dxos/react-client/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 { type TableRow, TableModel, type TableModelProps, type TableRowAction } from '../model';
+import { TableModel, type TableModelProps, type TableRow, type TableRowAction } from '../model';
+import { type Table } from '../types';
 
 export type UseTableModelParams<T extends TableRow = TableRow> = {
-  view?: DataType.View;
-  schema?: JsonSchemaType;
+  object?: Table.Table;
   projection?: ProjectionModel;
   rows?: Live<T>[];
   rowActions?: TableRowAction[];
@@ -29,8 +28,7 @@ export type UseTableModelParams<T extends TableRow = TableRow> = {
 >;
 
 export const useTableModel = <T extends TableRow = TableRow>({
-  view,
-  schema,
+  object,
   projection,
   rows,
   rowActions,
@@ -39,20 +37,19 @@ export const useTableModel = <T extends TableRow = TableRow>({
   onRowAction,
   ...props
 }: UseTableModelParams<T>): TableModel<T> | undefined => {
-  const selected = useSelected(view && fullyQualifiedId(view), 'multi');
-  const initialSelection = useMemo(() => selected, [view]);
+  const selected = useSelected(object && Obj.getDXN(object).toString(), '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,
+        object,
         projection,
         features,
         rowActions,
@@ -68,7 +65,8 @@ 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?
+  }, [object, projection, features, rowActions, initialSelection]);
 
   // Update data.
   useEffect(() => {

package/src/model/modal-controller.ts

@@ -3,10 +3,7 @@
 //
 
 import { signal } from '@preact/signals-core';
-import { type RefObject, type MutableRefObject } from 'react';
-
-import { type Live } from '@dxos/live-object';
-import { log } from '@dxos/log';
+import { type MutableRefObject, type RefObject } from 'react';
 
 export type ColumnSettingsMode = { type: 'create' } | { type: 'edit'; fieldId: string };
 
@@ -14,12 +11,6 @@ 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' };
 
@@ -68,25 +59,6 @@ export class ModalController {
     }
   };
 
-  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' };
   };

package/src/model/selection-model.ts

@@ -2,13 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-import { computed, effect, type Signal, signal, type ReadonlySignal } from '@preact/signals-core';
+import { type ReadonlySignal, type Signal, computed, effect, signal } from '@preact/signals-core';
 
 import { Resource } from '@dxos/context';
 
-import { type TableRow } from './table-model';
 import { touch } from '../util';
 
+import { type TableRow } from './table-model';
+
 export type SelectionMode = 'single' | 'multiple';
 
 export class SelectionModel<T extends TableRow> extends Resource {

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

@@ -3,19 +3,20 @@
 //
 
 import { computed } from '@preact/signals-core';
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
-import { Obj } from '@dxos/echo';
-import { TypedObject } from '@dxos/echo-schema';
-import { updateCounter } from '@dxos/echo-schema/testing';
+import { Filter, Query } from '@dxos/echo';
+import { TypedObject } from '@dxos/echo/internal';
+import { updateCounter } from '@dxos/echo/testing';
+import { createEchoSchema } from '@dxos/echo/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 { ProjectionModel, View } from '@dxos/schema';
+
+import { Table } from '../types';
 
 import { TableModel, type TableModelProps } from './table-model';
-import { TableView } from '../types';
 
 // TODO(burdon): Tests are disabled in project.json since they bring in plugin deps.
 //  Restore once factored out into react-ui-table.
@@ -24,7 +25,7 @@ registerSignalsRuntime();
 
 describe('TableModel', () => {
   let updateCount = 0;
-  let model: TableModel;
+  let model: any;
 
   beforeEach(async () => {
     updateCount = 0;
@@ -32,6 +33,11 @@ describe('TableModel', () => {
       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 () => {
@@ -72,7 +78,6 @@ describe('TableModel', () => {
   describe('reactivity', () => {
     it('pure signals should nest', () => {
       const signal$ = live({ arr: [{ thingInside: 1 }, { thingInside: 2 }] });
-
       const computed$ = computed(() => {
         return signal$.arr.map((row) =>
           computed(() => {
@@ -107,7 +112,11 @@ class Test extends TypedObject({ typename: 'example.com/type/Test', version: '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 view = View.make({
+    query: Query.select(Filter.type(schema)),
+    jsonSchema: schema.jsonSchema,
+  });
+  const object = Table.make({ view });
+  const projection = new ProjectionModel(schema.jsonSchema, view.projection);
+  return new TableModel({ object, projection, ...props });
 };