@dxos/react-ui-table 0.8.4-main.5ea62a8 → 0.8.4-main.66e292d

package/dist/lib/browser/{chunk-RQYXNWWN.mjs → chunk-KNC7XYT6.mjs}

@@ -1,11 +1,10 @@
 import {
-  schema_exports
-} from "./chunk-63UUF4IG.mjs";
+  Table_exports
+} from "./chunk-5XWSB3JP.mjs";
 
 // src/util/dynamic-table.ts
-import { Obj } from "@dxos/echo";
-import { getTypename, toJsonSchema } from "@dxos/echo-schema";
-import { ProjectionModel, createView, getSchemaFromPropertyDefinitions } from "@dxos/schema";
+import { Filter, Obj, Query, Ref, Type } from "@dxos/echo";
+import { ProjectionModel, View, getSchemaFromPropertyDefinitions } from "@dxos/schema";
 var getBaseSchema = ({ typename, properties, jsonSchema, schema }) => {
   if (typename && properties) {
     const schema2 = getSchemaFromPropertyDefinitions(typename, properties);
@@ -15,8 +14,8 @@ var getBaseSchema = ({ typename, properties, jsonSchema, schema }) => {
     };
   } else if (schema) {
     return {
-      typename: getTypename(schema),
-      jsonSchema: toJsonSchema(schema)
+      typename: Type.getTypename(schema),
+      jsonSchema: Type.toJsonSchema(schema)
     };
   } else if (typename && jsonSchema) {
     return {
@@ -27,25 +26,26 @@ var getBaseSchema = ({ typename, properties, jsonSchema, schema }) => {
     throw new Error("invalid properties");
   }
 };
-var makeDynamicTable = ({ typename, jsonSchema, properties }) => {
-  const table = Obj.make(schema_exports.Table, {
-    sizes: {}
-  });
-  const view = createView({
-    typename,
+var makeDynamicTable = ({ jsonSchema, properties }) => {
+  const view = View.make({
+    query: Query.select(Filter.everything()),
     jsonSchema,
-    presentation: table,
     ...properties && {
       fields: properties.map((property) => property.name)
     }
   });
+  const object = Obj.make(Table_exports.Table, {
+    view: Ref.make(view),
+    sizes: {}
+  });
   const projection = new ProjectionModel(jsonSchema, view.projection);
+  projection.normalizeView();
   if (properties && projection.fields) {
-    setProperties(view, projection, table, properties);
+    setProperties(view, projection, object, properties);
   }
   return {
     projection,
-    view
+    object
   };
 };
 var setProperties = (view, projection, table, properties) => {
@@ -67,7 +67,7 @@ var setProperties = (view, projection, table, properties) => {
       }
       if (property.sort) {
         const fieldId = field.id;
-        view.query.sort = [
+        view.sort = [
           {
             fieldId,
             direction: property.sort
@@ -255,14 +255,14 @@ var tableControls = {
 };
 
 // src/util/schema.ts
-import { Schema } from "effect";
-import { TypeLiteral, isTypeLiteral } from "effect/SchemaAST";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
 var narrowSchema = (schema, paths) => {
   const ast = schema?.ast;
-  if (isTypeLiteral(ast)) {
+  if (SchemaAST.isTypeLiteral(ast)) {
     const propertySignatures = ast.propertySignatures.filter((signature) => paths.includes(signature.name.toString()));
     if (propertySignatures.length > 0) {
-      const narrowType = new TypeLiteral(propertySignatures, []);
+      const narrowType = new SchemaAST.TypeLiteral(propertySignatures, []);
       return Schema.make(narrowType);
     }
   }
@@ -272,14 +272,13 @@ var narrowSchema = (schema, paths) => {
 // src/model/table-model.ts
 import { computed as computed3, effect as effect2, signal as signal3 } from "@preact/signals-core";
 import { Resource as Resource2 } from "@dxos/context";
-import { Obj as Obj2, Ref } from "@dxos/echo";
-import { FormatEnum as FormatEnum2, getSchema, getValue as getValue2, setValue, toEffectSchema } from "@dxos/echo-schema";
+import { Format as Format2, Obj as Obj2, Ref as Ref2 } from "@dxos/echo";
+import { getValue as getValue2, setValue, toEffectSchema } from "@dxos/echo/internal";
 import { invariant } from "@dxos/invariant";
 import { ObjectId } from "@dxos/keys";
 import { getSnapshot, isLiveObject } from "@dxos/live-object";
-import { fullyQualifiedId } from "@dxos/react-client/echo";
 import { formatForEditing, parseValue } from "@dxos/react-ui-form";
-import { ProjectionModel as ProjectionModel2, validateSchema } from "@dxos/schema";
+import { validateSchema } from "@dxos/schema";
 
 // src/util/tag.ts
 var TAG_PATTERN_REGEX = /\[([^\]]+)\]\(([^)]+)\)/g;
@@ -300,20 +299,34 @@ var extractTagIds = (value) => {
 // src/model/selection-model.ts
 import { computed, effect, signal } from "@preact/signals-core";
 import { Resource } from "@dxos/context";
-function _define_property(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var SelectionModel = class extends Resource {
+  _rows;
+  _selectionMode;
+  _initialSelection;
+  _onSelectionChanged;
+  _selection;
+  _validSelectedIds = computed(() => {
+    const rows = this._rows.value;
+    if (!rows) {
+      return /* @__PURE__ */ new Set();
+    }
+    const validIds = new Set(rows.map((row) => row.id));
+    return new Set([
+      ...this._selection.value
+    ].filter((id) => validIds.has(id)));
+  });
+  _hasSelection = computed(() => this._validSelectedIds.value.size > 0);
+  _allSelected = computed(() => {
+    const rows = this._rows.value;
+    if (rows.length === 0) {
+      return false;
+    }
+    return rows.every((row) => this._selection.value.has(row.id));
+  });
+  constructor(_rows, _selectionMode, _initialSelection, _onSelectionChanged) {
+    super(), this._rows = _rows, this._selectionMode = _selectionMode, this._initialSelection = _initialSelection, this._onSelectionChanged = _onSelectionChanged;
+    this._selection = signal(new Set(this._initialSelection));
+  }
   async _open() {
     const selectionWatcher = effect(() => {
       touch(this._selection.value);
@@ -336,80 +349,80 @@ var SelectionModel = class extends Resource {
   get selectionMode() {
     return this._selectionMode;
   }
-  constructor(_rows, _selectionMode, _initialSelection, _onSelectionChanged) {
-    super(), _define_property(this, "_rows", void 0), _define_property(this, "_selectionMode", void 0), _define_property(this, "_initialSelection", void 0), _define_property(this, "_onSelectionChanged", void 0), _define_property(this, "_selection", void 0), _define_property(this, "_validSelectedIds", void 0), _define_property(this, "_hasSelection", void 0), _define_property(this, "_allSelected", void 0), _define_property(this, "getSelectedRows", void 0), _define_property(this, "isRowIndexSelected", void 0), _define_property(this, "isObjectSelected", void 0), //
-    // Manipulation
-    //
-    _define_property(this, "toggleSelectionForRowIndex", void 0), _define_property(this, "setSelection", void 0), this._rows = _rows, this._selectionMode = _selectionMode, this._initialSelection = _initialSelection, this._onSelectionChanged = _onSelectionChanged, this._validSelectedIds = computed(() => {
-      const rows = this._rows.value;
-      if (!rows) {
-        return /* @__PURE__ */ new Set();
-      }
-      const validIds = new Set(rows.map((row) => row.id));
-      return new Set([
-        ...this._selection.value
-      ].filter((id) => validIds.has(id)));
-    }), this._hasSelection = computed(() => this._validSelectedIds.value.size > 0), this._allSelected = computed(() => {
-      const rows = this._rows.value;
-      if (rows.length === 0) {
-        return false;
+  getSelectedRows = () => {
+    const selectedIds = this._validSelectedIds.value;
+    return this._rows.value.filter((row) => selectedIds.has(row.id));
+  };
+  isRowIndexSelected = (rowIndex) => {
+    const row = this._rows.value[rowIndex];
+    return this._selection.value.has(row.id);
+  };
+  isObjectSelected = (object) => {
+    return this._selection.value.has(object.id);
+  };
+  //
+  // Manipulation
+  //
+  toggleSelectionForRowIndex = (rowIndex) => {
+    const row = this._rows.value[rowIndex];
+    const newSelection = new Set(this._selection.value);
+    if (newSelection.has(row.id)) {
+      newSelection.delete(row.id);
+    } else {
+      if (this._selectionMode === "single") {
+        newSelection.clear();
       }
-      return rows.every((row) => this._selection.value.has(row.id));
-    }), this.getSelectedRows = () => {
-      const selectedIds = this._validSelectedIds.value;
-      return this._rows.value.filter((row) => selectedIds.has(row.id));
-    }, this.isRowIndexSelected = (rowIndex) => {
-      const row = this._rows.value[rowIndex];
-      return this._selection.value.has(row.id);
-    }, this.isObjectSelected = (object) => {
-      return this._selection.value.has(object.id);
-    }, this.toggleSelectionForRowIndex = (rowIndex) => {
-      const row = this._rows.value[rowIndex];
-      const newSelection = new Set(this._selection.value);
-      if (newSelection.has(row.id)) {
-        newSelection.delete(row.id);
-      } else {
-        if (this._selectionMode === "single") {
-          newSelection.clear();
-        }
-        newSelection.add(row.id);
+      newSelection.add(row.id);
+    }
+    this._selection.value = newSelection;
+  };
+  setSelection = (mode) => {
+    switch (mode) {
+      case "all": {
+        this._selection.value = new Set(this._rows.value.map((row) => row.id));
+        break;
       }
-      this._selection.value = newSelection;
-    }, this.setSelection = (mode) => {
-      switch (mode) {
-        case "all": {
-          this._selection.value = new Set(this._rows.value.map((row) => row.id));
-          break;
-        }
-        case "none": {
-          this._selection.value = /* @__PURE__ */ new Set();
-          break;
-        }
+      case "none": {
+        this._selection.value = /* @__PURE__ */ new Set();
+        break;
       }
-    };
-    this._selection = signal(new Set(this._initialSelection));
-  }
+    }
+  };
 };
 
 // src/model/table-sorting.ts
 import { computed as computed2, signal as signal2 } from "@preact/signals-core";
 import orderBy from "lodash.orderby";
-import { FormatEnum, TypeEnum, getValue } from "@dxos/echo-schema";
+import { Format, TypeEnum, getValue } from "@dxos/echo/internal";
 import { formatForDisplay } from "@dxos/react-ui-form";
-function _define_property2(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
+var TableSorting = class {
+  _displayToDataIndex = /* @__PURE__ */ new Map();
+  _rows;
+  _getView;
+  _projection;
+  _localSort = signal2(void 0);
+  _isDirty;
+  sortedRows;
+  constructor({ rows, projection, getView }) {
+    this._rows = rows;
+    this._getView = getView;
+    this._projection = projection;
+    this._isDirty = computed2(() => {
+      const local = this._localSort.value;
+      const viewSort = this._getView().sort?.[0];
+      if (local?.type === "cleared") {
+        return viewSort !== void 0;
+      }
+      if (local?.type === "active") {
+        if (!viewSort) {
+          return true;
+        }
+        return local.sort.fieldId !== viewSort.fieldId || local.sort.direction !== viewSort.direction;
+      }
+      return false;
     });
-  } else {
-    obj[key] = value;
+    this.sortedRows = this.initialiseSortedRows();
   }
-  return obj;
-}
-var TableSorting = class {
   /**
   * @reactive
   * @returns Local sort if present, falls back to view sort.
@@ -422,7 +435,7 @@ var TableSorting = class {
     if (local?.type === "active") {
       return local.sort;
     }
-    return this._view.query.sort?.[0];
+    return this._getView().sort?.[0];
   }
   /**
   * @reactive
@@ -465,12 +478,13 @@ var TableSorting = class {
   }
   save() {
     if (this._localSort.value !== void 0) {
+      const view = this._getView();
       if (this._localSort.value.type === "active") {
-        this._view.query.sort = [
+        view.sort = [
           this._localSort.value.sort
         ];
       } else {
-        this._view.query.sort = [];
+        view.sort = [];
       }
       this._localSort.value = void 0;
     }
@@ -527,7 +541,7 @@ var TableSorting = class {
     if (value == null) {
       return value;
     }
-    if (format === FormatEnum.SingleSelect) {
+    if (format === Format.TypeFormat.SingleSelect) {
       const options = props.options;
       if (!options) {
         return void 0;
@@ -535,7 +549,7 @@ var TableSorting = class {
       const option = options.find((option2) => option2.id === value);
       return option ? options.indexOf(option) : void 0;
     }
-    if (format === FormatEnum.Ref && field.referencePath) {
+    if (format === Format.TypeFormat.Ref && field.referencePath) {
       const refValue = getValue(value.target, field.referencePath);
       return refValue;
     }
@@ -545,51 +559,9 @@ var TableSorting = class {
       value
     });
   }
-  constructor(rows, _view, _projection) {
-    _define_property2(this, "_view", void 0);
-    _define_property2(this, "_projection", void 0);
-    _define_property2(this, "_displayToDataIndex", void 0);
-    _define_property2(this, "_rows", void 0);
-    _define_property2(this, "_localSort", void 0);
-    _define_property2(this, "_isDirty", void 0);
-    _define_property2(this, "sortedRows", void 0);
-    this._view = _view;
-    this._projection = _projection;
-    this._displayToDataIndex = /* @__PURE__ */ new Map();
-    this._localSort = signal2(void 0);
-    this._rows = rows;
-    this._isDirty = computed2(() => {
-      const local = this._localSort.value;
-      const viewSort = this._view.query.sort?.[0];
-      if (local?.type === "cleared") {
-        return viewSort !== void 0;
-      }
-      if (local?.type === "active") {
-        if (!viewSort) {
-          return true;
-        }
-        return local.sort.fieldId !== viewSort.fieldId || local.sort.direction !== viewSort.direction;
-      }
-      return false;
-    });
-    this.sortedRows = this.initialiseSortedRows();
-  }
 };
 
 // src/model/table-model.ts
-function _define_property3(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var __dxlog_file = "/__w/dxos/dxos/packages/ui/react-ui-table/src/model/table-model.ts";
 var defaultFeatures = {
   selection: {
@@ -600,23 +572,90 @@ var defaultFeatures = {
   schemaEditable: false
 };
 var TableModel = class extends Resource2 {
+  _object;
+  _projection;
+  _visibleRange = signal3({
+    start: {
+      row: 0,
+      col: 0
+    },
+    end: {
+      row: 0,
+      col: 0
+    }
+  });
+  _onInsertRow;
+  _onDeleteRows;
+  _onDeleteColumn;
+  _onCellUpdate;
+  _onRowOrderChange;
+  _onRowAction;
+  _rowActions;
+  _features;
+  _rows = signal3([]);
+  _draftRows = signal3([]);
+  _sorting;
+  _pinnedRows;
+  _selection;
+  _columnMeta;
+  constructor({ object, projection, features = {}, sorting = [], initialSelection = [], pinnedRows = {
+    top: [],
+    bottom: []
+  }, rowActions = [], onCellUpdate, onDeleteColumn, onDeleteRows, onInsertRow, onRowOrderChange, onRowAction }) {
+    super();
+    this._object = object;
+    this._projection = projection;
+    this._projection.normalizeView();
+    this._features = {
+      ...defaultFeatures,
+      ...features
+    };
+    invariant(!(this._features.dataEditable && this._features.selection.enabled && this._features.selection.mode === "single"), "Single selection is not compatible with editable tables.", {
+      F: __dxlog_file,
+      L: 137,
+      S: this,
+      A: [
+        "!(this._features.dataEditable && this._features.selection.enabled && this._features.selection.mode === 'single')",
+        "'Single selection is not compatible with editable tables.'"
+      ]
+    });
+    this._sorting = new TableSorting({
+      rows: this._rows,
+      getView: () => this.view,
+      projection: this._projection
+    });
+    if (sorting.length > 0) {
+      const [sort] = sorting;
+      this._sorting.setSort(sort.fieldId, sort.direction);
+    }
+    this._selection = new SelectionModel(this._sorting.sortedRows, this._features.selection.mode ?? "multiple", initialSelection, () => this._onRowOrderChange?.());
+    this._pinnedRows = pinnedRows;
+    this._rowActions = rowActions;
+    this._onInsertRow = onInsertRow;
+    this._onDeleteRows = onDeleteRows;
+    this._onDeleteColumn = onDeleteColumn;
+    this._onCellUpdate = onCellUpdate;
+    this._onRowOrderChange = onRowOrderChange;
+    this._onRowAction = onRowAction;
+  }
   get id() {
-    return fullyQualifiedId(this._view);
+    return Obj2.getDXN(this._object).toString();
   }
   get view() {
-    return this._view;
-  }
-  get table() {
-    invariant(this._table, "Model not initialized", {
+    const view = this._object.view.target;
+    invariant(view, "Table model not initialized", {
       F: __dxlog_file,
-      L: 180,
+      L: 176,
       S: this,
       A: [
-        "this._table",
-        "'Model not initialized'"
+        "view",
+        "'Table model not initialized'"
       ]
     });
-    return this._table;
+    return view;
+  }
+  get table() {
+    return this._object;
   }
   get projection() {
     return this._projection;
@@ -671,17 +710,7 @@ var TableModel = class extends Resource2 {
   // Initialisation
   //
   async _open() {
-    const presentation = this._view.presentation.target ?? await this._view.presentation.load();
-    invariant(Obj2.instanceOf(schema_exports.Table, presentation), void 0, {
-      F: __dxlog_file,
-      L: 242,
-      S: this,
-      A: [
-        "Obj.instanceOf(Table.Table, presentation)",
-        ""
-      ]
-    });
-    this._table = presentation;
+    await this._object.view.load();
     this.initializeColumnMeta();
     this.initializeEffects();
     await this._selection.open(this._ctx);
@@ -742,6 +771,17 @@ var TableModel = class extends Resource2 {
     });
     this._ctx.onDispose(draftRowsWatcher);
   }
+  //
+  // Data
+  //
+  setRows = (obj) => {
+    this._rows.value = obj;
+  };
+  getRowCount = () => this._rows.value.length;
+  /**
+  * @reactive
+  */
+  getDraftRowCount = () => this._draftRows.value.length;
   // TODO(ZaymonFC): Return .value instead of exposing the signal.
   get draftRows() {
     return this._draftRows;
@@ -760,6 +800,14 @@ var TableModel = class extends Resource2 {
     const validationErrors = draftRow.validationErrors || [];
     return validationErrors.some((error) => error.path === fieldPath);
   }
+  getColumnCount = () => this._projection?.fields.length ?? 0;
+  insertRow = () => {
+    const result = this._onInsertRow?.();
+    if (result === "draft" && this._draftRows.value.length === 0) {
+      this.createDraftRow();
+    }
+    return result ?? "final";
+  };
   createDraftRow() {
     if (!this._projection) {
       return;
@@ -799,6 +847,187 @@ var TableModel = class extends Resource2 {
     const schema = toEffectSchema(this._projection.baseSchema);
     return validateSchema(schema, data) || [];
   }
+  commitDraftRow = (draftRowIndex) => {
+    if (draftRowIndex < 0 || draftRowIndex >= this._draftRows.value.length) {
+      return false;
+    }
+    const draftRow = this._draftRows.value[draftRowIndex];
+    if (!draftRow.valid) {
+      return false;
+    }
+    const insertRowResult = this._onInsertRow?.(draftRow.data);
+    if (insertRowResult === "final") {
+      const newDraftRows = this._draftRows.value.filter((_, index) => index !== draftRowIndex);
+      this._draftRows.value = newDraftRows;
+    }
+    return insertRowResult === "final";
+  };
+  deleteRow = (rowIndex) => {
+    const row = this._sorting.getDataIndex(rowIndex);
+    const obj = this._rows.value[row];
+    const objectsToDelete = [];
+    if (this.features.selection.enabled && this._selection.hasSelection.value) {
+      const selectedRows = this._selection.getSelectedRows();
+      objectsToDelete.push(...selectedRows);
+    } else {
+      objectsToDelete.push(obj);
+    }
+    this._onDeleteRows?.(row, objectsToDelete);
+  };
+  handleRowAction = (actionId, rowIndex) => {
+    if (!this._onRowAction) {
+      return;
+    }
+    const row = this._sorting.getDataIndex(rowIndex);
+    const data = this._rows.value[row];
+    if (data) {
+      this._onRowAction(actionId, data);
+    }
+  };
+  getCellData = (cell) => {
+    const { col, row, plane } = cell;
+    const fields = this._projection?.fields ?? [];
+    if (col < 0 || col >= fields.length) {
+      return void 0;
+    }
+    const field = fields[col];
+    let value;
+    if (plane === "frozenRowsEnd") {
+      if (row >= 0 && row < this._draftRows.value.length) {
+        value = getValue2(this._draftRows.value[row].data, field.path);
+      } else {
+        return void 0;
+      }
+    } else {
+      const dataIndex = this._sorting.getDataIndex(row);
+      value = getValue2(this._rows.value[dataIndex], field.path);
+    }
+    if (value == null) {
+      return "";
+    }
+    const { props } = this._projection.getFieldProjection(field.id);
+    switch (props.format) {
+      case Format2.TypeFormat.Ref: {
+        if (!field.referencePath) {
+          return "";
+        }
+        return getValue2(value.target, field.referencePath);
+      }
+      default: {
+        return formatForEditing({
+          type: props.type,
+          format: props.format,
+          value
+        });
+      }
+    }
+  };
+  validateCellData = async ({ col, row, plane }, value) => {
+    const fields = this._projection?.fields ?? [];
+    if (col < 0 || col >= fields.length) {
+      return {
+        valid: false,
+        error: "Invalid column index"
+      };
+    }
+    const field = fields[col];
+    const { props } = this._projection.getFieldProjection(field.id);
+    const transformedValue = editorTextToCellValue(props, value);
+    const isDraftRow = plane === "frozenRowsEnd";
+    if (isDraftRow) {
+      const isInvalidDraftRowIndex = row < 0 || row >= this._draftRows.value.length;
+      if (isInvalidDraftRowIndex) {
+        return {
+          valid: false,
+          error: "Invalid draft row index"
+        };
+      }
+      const draftRow = this._draftRows.value[row];
+      const snapshot = {
+        ...draftRow.data
+      };
+      setValue(snapshot, field.path, transformedValue);
+      const validationErrors = this.validateDraftRowData(snapshot);
+      if (validationErrors.length > 0) {
+        const error = validationErrors.find((err) => err.path === field.path);
+        if (error) {
+          return {
+            valid: false,
+            error: error.message
+          };
+        }
+      }
+      return {
+        valid: true
+      };
+    } else {
+      const rowIdx = this._sorting.getDataIndex(row);
+      const currentRow = this._rows.value[rowIdx];
+      invariant(currentRow, "Invalid row index", {
+        F: __dxlog_file,
+        L: 516,
+        S: this,
+        A: [
+          "currentRow",
+          "'Invalid row index'"
+        ]
+      });
+      const snapshot = getSnapshot(currentRow);
+      setValue(snapshot, field.path, transformedValue);
+      const schema = Obj2.getSchema(currentRow);
+      invariant(schema, void 0, {
+        F: __dxlog_file,
+        L: 522,
+        S: this,
+        A: [
+          "schema",
+          ""
+        ]
+      });
+      const validationResult = validateSchema(schema, snapshot);
+      if (validationResult && validationResult.length > 0) {
+        const error = validationResult[0];
+        invariant(error.path === field.path, void 0, {
+          F: __dxlog_file,
+          L: 527,
+          S: this,
+          A: [
+            "error.path === field.path",
+            ""
+          ]
+        });
+        return {
+          valid: false,
+          error: error.message
+        };
+      }
+      return {
+        valid: true
+      };
+    }
+  };
+  setCellData = (cell, value) => {
+    const { col, row, plane } = cell;
+    const fields = this._projection?.fields ?? [];
+    if (col < 0 || col >= fields.length) {
+      return;
+    }
+    const field = fields[col];
+    const { props } = this._projection.getFieldProjection(field.id);
+    const transformedValue = editorTextToCellValue(props, value);
+    if (props.format === Format2.TypeFormat.Ref && !isLiveObject(value)) {
+      return;
+    }
+    if (plane === "frozenRowsEnd") {
+      if (row >= 0 && row < this._draftRows.value.length) {
+        setValue(this._draftRows.value[row].data, field.path, transformedValue);
+        this.validateDraftRow(row);
+      }
+    } else {
+      const rowIdx = this._sorting.getDataIndex(row);
+      setValue(this._rows.value[rowIdx], field.path, transformedValue);
+    }
+  };
   /**
   * Updates a cell's value using a transform function.
   * @param {DxGridPlanePosition} position - The position of the cell to update.
@@ -879,250 +1108,17 @@ var TableModel = class extends Resource2 {
   saveView() {
     this._sorting.save();
   }
-  constructor({ view, schema, projection, features = {}, sorting = [], initialSelection = [], pinnedRows = {
-    top: [],
-    bottom: []
-  }, rowActions = [], onCellUpdate, onDeleteColumn, onDeleteRows, onInsertRow, onRowOrderChange, onRowAction }) {
-    super(), _define_property3(this, "_view", void 0), _define_property3(this, "_projection", void 0), _define_property3(this, "_table", void 0), _define_property3(this, "_visibleRange", signal3({
-      start: {
-        row: 0,
-        col: 0
-      },
-      end: {
-        row: 0,
-        col: 0
-      }
-    })), _define_property3(this, "_onInsertRow", void 0), _define_property3(this, "_onDeleteRows", void 0), _define_property3(this, "_onDeleteColumn", void 0), _define_property3(this, "_onCellUpdate", void 0), _define_property3(this, "_onRowOrderChange", void 0), _define_property3(this, "_onRowAction", void 0), _define_property3(this, "_rowActions", void 0), _define_property3(this, "_features", void 0), _define_property3(this, "_rows", signal3([])), _define_property3(this, "_draftRows", signal3([])), _define_property3(this, "_sorting", void 0), _define_property3(this, "_pinnedRows", void 0), _define_property3(this, "_selection", void 0), _define_property3(this, "_columnMeta", void 0), //
-    // Data
-    //
-    _define_property3(this, "setRows", (obj) => {
-      this._rows.value = obj;
-    }), _define_property3(this, "getRowCount", () => this._rows.value.length), /**
-    * @reactive
-    */
-    _define_property3(this, "getDraftRowCount", () => this._draftRows.value.length), _define_property3(this, "getColumnCount", () => this._projection?.fields.length ?? 0), _define_property3(this, "insertRow", () => {
-      const result = this._onInsertRow?.();
-      if (result === "draft" && this._draftRows.value.length === 0) {
-        this.createDraftRow();
-      }
-      return result ?? "final";
-    }), _define_property3(this, "commitDraftRow", (draftRowIndex) => {
-      if (draftRowIndex < 0 || draftRowIndex >= this._draftRows.value.length) {
-        return false;
-      }
-      const draftRow = this._draftRows.value[draftRowIndex];
-      if (!draftRow.valid) {
-        return false;
-      }
-      const insertRowResult = this._onInsertRow?.(draftRow.data);
-      if (insertRowResult === "final") {
-        const newDraftRows = this._draftRows.value.filter((_, index) => index !== draftRowIndex);
-        this._draftRows.value = newDraftRows;
-      }
-      return insertRowResult === "final";
-    }), _define_property3(this, "deleteRow", (rowIndex) => {
-      const row = this._sorting.getDataIndex(rowIndex);
-      const obj = this._rows.value[row];
-      const objectsToDelete = [];
-      if (this.features.selection.enabled && this._selection.hasSelection.value) {
-        const selectedRows = this._selection.getSelectedRows();
-        objectsToDelete.push(...selectedRows);
-      } else {
-        objectsToDelete.push(obj);
-      }
-      this._onDeleteRows?.(row, objectsToDelete);
-    }), _define_property3(this, "handleRowAction", (actionId, rowIndex) => {
-      if (!this._onRowAction) {
-        return;
-      }
-      const row = this._sorting.getDataIndex(rowIndex);
-      const data = this._rows.value[row];
-      if (data) {
-        this._onRowAction(actionId, data);
-      }
-    }), _define_property3(this, "getCellData", (cell) => {
-      const { col, row, plane } = cell;
-      const fields = this._projection?.fields ?? [];
-      if (col < 0 || col >= fields.length) {
-        return void 0;
-      }
-      const field = fields[col];
-      let value;
-      if (plane === "frozenRowsEnd") {
-        if (row >= 0 && row < this._draftRows.value.length) {
-          value = getValue2(this._draftRows.value[row].data, field.path);
-        } else {
-          return void 0;
-        }
-      } else {
-        const dataIndex = this._sorting.getDataIndex(row);
-        value = getValue2(this._rows.value[dataIndex], field.path);
-      }
-      if (value == null) {
-        return "";
-      }
-      const { props } = this._projection.getFieldProjection(field.id);
-      switch (props.format) {
-        case FormatEnum2.Ref: {
-          if (!field.referencePath) {
-            return "";
-          }
-          return getValue2(value.target, field.referencePath);
-        }
-        default: {
-          return formatForEditing({
-            type: props.type,
-            format: props.format,
-            value
-          });
-        }
-      }
-    }), _define_property3(this, "validateCellData", async ({ col, row, plane }, value) => {
-      const fields = this._projection?.fields ?? [];
-      if (col < 0 || col >= fields.length) {
-        return {
-          valid: false,
-          error: "Invalid column index"
-        };
-      }
-      const field = fields[col];
-      const { props } = this._projection.getFieldProjection(field.id);
-      const transformedValue = editorTextToCellValue(props, value);
-      const isDraftRow = plane === "frozenRowsEnd";
-      if (isDraftRow) {
-        const isInvalidDraftRowIndex = row < 0 || row >= this._draftRows.value.length;
-        if (isInvalidDraftRowIndex) {
-          return {
-            valid: false,
-            error: "Invalid draft row index"
-          };
-        }
-        const draftRow = this._draftRows.value[row];
-        const snapshot = {
-          ...draftRow.data
-        };
-        setValue(snapshot, field.path, transformedValue);
-        const validationErrors = this.validateDraftRowData(snapshot);
-        if (validationErrors.length > 0) {
-          const error = validationErrors.find((err) => err.path === field.path);
-          if (error) {
-            return {
-              valid: false,
-              error: error.message
-            };
-          }
-        }
-        return {
-          valid: true
-        };
-      } else {
-        const rowIdx = this._sorting.getDataIndex(row);
-        const currentRow = this._rows.value[rowIdx];
-        invariant(currentRow, "Invalid row index", {
-          F: __dxlog_file,
-          L: 515,
-          S: this,
-          A: [
-            "currentRow",
-            "'Invalid row index'"
-          ]
-        });
-        const snapshot = getSnapshot(currentRow);
-        setValue(snapshot, field.path, transformedValue);
-        const schema2 = getSchema(currentRow);
-        invariant(schema2, void 0, {
-          F: __dxlog_file,
-          L: 521,
-          S: this,
-          A: [
-            "schema",
-            ""
-          ]
-        });
-        const validationResult = validateSchema(schema2, snapshot);
-        if (validationResult && validationResult.length > 0) {
-          const error = validationResult[0];
-          invariant(error.path === field.path, void 0, {
-            F: __dxlog_file,
-            L: 526,
-            S: this,
-            A: [
-              "error.path === field.path",
-              ""
-            ]
-          });
-          return {
-            valid: false,
-            error: error.message
-          };
-        }
-        return {
-          valid: true
-        };
-      }
-    }), _define_property3(this, "setCellData", (cell, value) => {
-      const { col, row, plane } = cell;
-      const fields = this._projection?.fields ?? [];
-      if (col < 0 || col >= fields.length) {
-        return;
-      }
-      const field = fields[col];
-      const { props } = this._projection.getFieldProjection(field.id);
-      const transformedValue = editorTextToCellValue(props, value);
-      if (props.format === FormatEnum2.Ref && !isLiveObject(value)) {
-        return;
-      }
-      if (plane === "frozenRowsEnd") {
-        if (row >= 0 && row < this._draftRows.value.length) {
-          setValue(this._draftRows.value[row].data, field.path, transformedValue);
-          this.validateDraftRow(row);
-        }
-      } else {
-        const rowIdx = this._sorting.getDataIndex(row);
-        setValue(this._rows.value[rowIdx], field.path, transformedValue);
-      }
-    });
-    this._view = view;
-    this._projection = projection ?? new ProjectionModel2(schema, view.projection);
-    this._features = {
-      ...defaultFeatures,
-      ...features
-    };
-    invariant(!(this._features.dataEditable && this._features.selection.enabled && this._features.selection.mode === "single"), "Single selection is not compatible with editable tables.", {
-      F: __dxlog_file,
-      L: 142,
-      S: this,
-      A: [
-        "!(this._features.dataEditable && this._features.selection.enabled && this._features.selection.mode === 'single')",
-        "'Single selection is not compatible with editable tables.'"
-      ]
-    });
-    this._sorting = new TableSorting(this._rows, this._view, this._projection);
-    if (sorting.length > 0) {
-      const [sort] = sorting;
-      this._sorting.setSort(sort.fieldId, sort.direction);
-    }
-    this._selection = new SelectionModel(this._sorting.sortedRows, this._features.selection.mode ?? "multiple", initialSelection, () => this._onRowOrderChange?.());
-    this._pinnedRows = pinnedRows;
-    this._rowActions = rowActions;
-    this._onInsertRow = onInsertRow;
-    this._onDeleteRows = onDeleteRows;
-    this._onDeleteColumn = onDeleteColumn;
-    this._onCellUpdate = onCellUpdate;
-    this._onRowOrderChange = onRowOrderChange;
-    this._onRowAction = onRowAction;
-  }
 };
 var editorTextToCellValue = (props, value) => {
   switch (props.format) {
-    case FormatEnum2.Ref: {
+    case Format2.TypeFormat.Ref: {
       if (isLiveObject(value)) {
-        return Ref.make(value);
+        return Ref2.make(value);
       } else {
         return value;
       }
     }
-    case FormatEnum2.SingleSelect: {
+    case Format2.TypeFormat.SingleSelect: {
       const ids = extractTagIds(value);
       if (ids && ids.length > 0) {
         return ids[0];
@@ -1130,7 +1126,7 @@ var editorTextToCellValue = (props, value) => {
         return value;
       }
     }
-    case FormatEnum2.MultiSelect: {
+    case Format2.TypeFormat.MultiSelect: {
       const ids = extractTagIds(value);
       return ids || value;
     }
@@ -1146,128 +1142,96 @@ var editorTextToCellValue = (props, value) => {
 
 // src/model/modal-controller.ts
 import { signal as signal4 } from "@preact/signals-core";
-import { log } from "@dxos/log";
-function _define_property4(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-var __dxlog_file2 = "/__w/dxos/dxos/packages/ui/react-ui-table/src/model/modal-controller.ts";
 var ModalController = class {
+  _state = signal4({
+    type: "closed"
+  });
+  _triggerRef = {
+    current: null
+  };
   get state() {
     return this._state;
   }
   get trigger() {
     return this._triggerRef;
   }
-  constructor() {
-    _define_property4(this, "_state", signal4({
-      type: "closed"
-    }));
-    _define_property4(this, "_triggerRef", {
-      current: null
-    });
-    _define_property4(this, "setTrigger", (trigger) => {
-      this._triggerRef.current = trigger;
-    });
-    _define_property4(this, "showRowMenu", (rowIndex) => {
-      this._state.value = {
-        type: "row",
-        rowIndex
-      };
-    });
-    _define_property4(this, "showColumnMenu", (fieldId) => {
-      this._state.value = {
-        type: "column",
-        fieldId
-      };
-    });
-    _define_property4(this, "showColumnCreator", () => {
-      this._state.value = {
-        type: "columnSettings",
-        mode: {
-          type: "create"
-        }
-      };
-    });
-    _define_property4(this, "showReferencePanel", (targetId, schemaId) => {
-      this._state.value = {
-        type: "refPanel",
-        targetId,
-        typename: schemaId
-      };
-    });
-    _define_property4(this, "openColumnSettings", () => {
-      if (this._state.value.type === "column") {
-        const fieldId = this._state.value.fieldId;
-        requestAnimationFrame(() => {
-          this._state.value = {
-            type: "columnSettings",
-            mode: {
-              type: "edit",
-              fieldId
-            }
-          };
-        });
+  setTrigger = (trigger) => {
+    this._triggerRef.current = trigger;
+  };
+  showRowMenu = (rowIndex) => {
+    this._state.value = {
+      type: "row",
+      rowIndex
+    };
+  };
+  showColumnMenu = (fieldId) => {
+    this._state.value = {
+      type: "column",
+      fieldId
+    };
+  };
+  showColumnCreator = () => {
+    this._state.value = {
+      type: "columnSettings",
+      mode: {
+        type: "create"
       }
-    });
-    _define_property4(this, "openCreateRef", (typename, anchorCell, initialValues, onCreate) => {
-      if (anchorCell) {
-        this._triggerRef.current = anchorCell;
+    };
+  };
+  showReferencePanel = (targetId, schemaId) => {
+    this._state.value = {
+      type: "refPanel",
+      targetId,
+      typename: schemaId
+    };
+  };
+  openColumnSettings = () => {
+    if (this._state.value.type === "column") {
+      const fieldId = this._state.value.fieldId;
+      requestAnimationFrame(() => {
         this._state.value = {
-          type: "createRefPanel",
-          typename,
-          initialValues,
-          onCreate
+          type: "columnSettings",
+          mode: {
+            type: "edit",
+            fieldId
+          }
         };
-      } else {
-        log.warn("anchor cell not found while creating new ref", void 0, {
-          F: __dxlog_file2,
-          L: 86,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    });
-    _define_property4(this, "close", () => {
-      this._state.value = {
-        type: "closed"
-      };
-    });
-  }
+      });
+    }
+  };
+  close = () => {
+    this._state.value = {
+      type: "closed"
+    };
+  };
 };
 
 // src/model/table-presentation.ts
 import { signal as signal5 } from "@preact/signals-core";
-import { isNotNullable } from "effect/Predicate";
+import * as Predicate from "effect/Predicate";
 import { Obj as Obj3 } from "@dxos/echo";
-import { FormatEnum as FormatEnum3, TypeEnum as TypeEnum2, getValue as getValue3 } from "@dxos/echo-schema";
+import { Format as Format3, TypeEnum as TypeEnum2, getValue as getValue3 } from "@dxos/echo/internal";
 import { cellClassesForFieldType, formatForDisplay as formatForDisplay2 } from "@dxos/react-ui-form";
 import { toPlaneCellIndex } from "@dxos/react-ui-grid";
 import { mx } from "@dxos/react-ui-theme";
 import { VIEW_FIELD_LIMIT } from "@dxos/schema";
-function _define_property5(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var TablePresentation = class {
+  model;
+  _visibleRange;
+  fieldProjectionCache = /* @__PURE__ */ new Map();
+  constructor(model, _visibleRange = signal5({
+    start: {
+      row: 0,
+      col: 0
+    },
+    end: {
+      row: 0,
+      col: 0
+    }
+  })) {
+    this.model = model;
+    this._visibleRange = _visibleRange;
+  }
   getCells(range, plane) {
     this.fieldProjectionCache.clear();
     let cells;
@@ -1333,12 +1297,12 @@ var TablePresentation = class {
           return "";
         }
         switch (props.format) {
-          case FormatEnum3.Boolean:
-          case FormatEnum3.SingleSelect:
-          case FormatEnum3.MultiSelect: {
+          case Format3.TypeFormat.Boolean:
+          case Format3.TypeFormat.SingleSelect:
+          case Format3.TypeFormat.MultiSelect: {
             return "";
           }
-          case FormatEnum3.Ref: {
+          case Format3.TypeFormat.Ref: {
             if (!field.referencePath) {
               return "";
             }
@@ -1385,20 +1349,20 @@ var TablePresentation = class {
           }
           return "Object";
         };
-        const tags = targetArray.map(getLabel).filter(isNotNullable).map((title) => {
+        const tags = targetArray.map(getLabel).filter(Predicate.isNotNullable).map((title) => {
           return `<span class="dx-tag" data-hue="neutral">${title}</span>`;
         }).join("");
         cell.accessoryHtml = `<div role='none' class="flex flex-row gap-1 overflow-x-auto">${tags}</div>`;
       }
     }
-    if (props.format === FormatEnum3.Ref && props.referenceSchema) {
+    if (props.format === Format3.TypeFormat.Ref && props.referenceSchema) {
       const targetObj = getValue3(obj, field.path)?.target;
       if (targetObj) {
         const dxn = Obj3.getDXN(targetObj)?.toString();
-        cell.accessoryHtml = `<dx-ref-tag refId=${dxn} class="dx-button is-6 pli-[3px] pbe-[2px] min-bs-0 absolute inline-end-2 block-start-[.2rem]" data-dx-grid-action="accessory"><dx-icon icon="ph--link-simple--regular"/></dx-ref-tag>`;
+        cell.accessoryHtml = `<div role="none" class="absolute inline-end-0 inset-block-0 p-[--dx-grid-cell-content-padding-block]"><dx-anchor refId=${dxn} class="dx-button is-6 aspect-square min-bs-0" data-dx-grid-action="accessory"><dx-icon icon="ph--link-simple--regular"/></dx-anchor></div>`;
       }
     }
-    if (props.format === FormatEnum3.Boolean) {
+    if (props.format === Format3.TypeFormat.Boolean) {
       const value = getValue3(obj, field.path);
       cell.accessoryHtml = tableControls.switch.render({
         colIndex,
@@ -1407,7 +1371,7 @@ var TablePresentation = class {
       });
       cell.readonly = "no-text-select";
     }
-    if (props.format === FormatEnum3.SingleSelect) {
+    if (props.format === Format3.TypeFormat.SingleSelect) {
       const value = getValue3(obj, field.path);
       const options = this.model.projection.getFieldProjection(field.id).props.options;
       if (options) {
@@ -1417,7 +1381,7 @@ var TablePresentation = class {
         }
       }
     }
-    if (props.format === FormatEnum3.MultiSelect) {
+    if (props.format === Format3.TypeFormat.MultiSelect) {
       const values = getValue3(obj, field.path);
       const options = this.model.projection.getFieldProjection(field.id).props.options;
       if (options && values && values.length > 0) {
@@ -1653,23 +1617,6 @@ var TablePresentation = class {
     }
     return cells;
   }
-  constructor(model, _visibleRange = signal5({
-    start: {
-      row: 0,
-      col: 0
-    },
-    end: {
-      row: 0,
-      col: 0
-    }
-  })) {
-    _define_property5(this, "model", void 0);
-    _define_property5(this, "_visibleRange", void 0);
-    _define_property5(this, "fieldProjectionCache", void 0);
-    this.model = model;
-    this._visibleRange = _visibleRange;
-    this.fieldProjectionCache = /* @__PURE__ */ new Map();
-  }
 };
 var cellClassesForRowSelection = (selected, selectionMode) => {
   if (!selected) {
@@ -1693,31 +1640,65 @@ var cellClassesForRowSelection = (selected, selectionMode) => {
   }
 };
 
+// src/hooks/useAddRow.ts
+import { useCallback } from "react";
+import { Obj as Obj4 } from "@dxos/echo";
+var useAddRow = ({ space, schema }) => {
+  return useCallback((data) => {
+    if (space && schema) {
+      try {
+        space.db.add(Obj4.make(schema, data ?? {}));
+        return "final";
+      } catch (error) {
+        return "draft";
+      }
+    }
+    return "final";
+  }, [
+    space,
+    schema
+  ]);
+};
+
+// src/hooks/useProjectionModel.ts
+import { useMemo } from "react";
+import { Type as Type2 } from "@dxos/echo";
+import { ProjectionModel as ProjectionModel2 } from "@dxos/schema";
+var useProjectionModel = (schema, table) => useMemo(() => {
+  if (schema && table?.view.target?.projection) {
+    const projection = new ProjectionModel2(Type2.toJsonSchema(schema), table.view.target.projection);
+    projection.normalizeView();
+    return projection;
+  }
+}, [
+  schema,
+  table?.view.target?.projection
+]);
+
 // src/hooks/useTableModel.ts
 import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
 import { effect as effect3 } from "@preact/signals-core";
 import orderBy2 from "lodash.orderby";
-import { useEffect, useMemo, useState } from "react";
-import { fullyQualifiedId as fullyQualifiedId2 } from "@dxos/react-client/echo";
+import { useEffect, useMemo as useMemo2, useState } from "react";
+import { Obj as Obj5 } from "@dxos/echo";
 import { useSelected, useSelectionActions } from "@dxos/react-ui-attention";
 import { isNonNullable } from "@dxos/util";
-var useTableModel = ({ view, schema, projection, rows, rowActions, features, onSelectionChanged, onRowAction, ...props }) => {
+var useTableModel = ({ object, projection, rows, rowActions, features, onSelectionChanged, onRowAction, ...props }) => {
   var _effect = _useSignals();
   try {
-    const selected = useSelected(view && fullyQualifiedId2(view), "multi");
-    const initialSelection = useMemo(() => selected, [
-      view
+    const selected = useSelected(object && Obj5.getDXN(object).toString(), "multi");
+    const initialSelection = useMemo2(() => selected, [
+      object
     ]);
     const [model, setModel] = useState();
     useEffect(() => {
-      if (!view || !schema) {
+      if (!object || !projection) {
         return;
       }
       let model2;
       const t = setTimeout(async () => {
         model2 = new TableModel({
-          view,
-          schema,
+          object,
           projection,
           features,
           rowActions,
@@ -1733,8 +1714,7 @@ var useTableModel = ({ view, schema, projection, rows, rowActions, features, onS
         void model2?.close();
       };
     }, [
-      view,
-      schema,
+      object,
       projection,
       features,
       rowActions,
@@ -1781,26 +1761,6 @@ var useTableModel = ({ view, schema, projection, rows, rowActions, features, onS
   }
 };
 
-// src/hooks/useAddRow.ts
-import { useCallback } from "react";
-import { Obj as Obj4 } from "@dxos/echo";
-var useAddRow = ({ space, schema }) => {
-  return useCallback((data) => {
-    if (space && schema) {
-      try {
-        space.db.add(Obj4.make(schema, data ?? {}));
-        return "final";
-      } catch (error) {
-        return "draft";
-      }
-    }
-    return "final";
-  }, [
-    space,
-    schema
-  ]);
-};
-
 export {
   getBaseSchema,
   makeDynamicTable,
@@ -1816,7 +1776,8 @@ export {
   ModalController,
   TablePresentation,
   cellClassesForRowSelection,
-  useTableModel,
-  useAddRow
+  useAddRow,
+  useProjectionModel,
+  useTableModel
 };
-//# sourceMappingURL=chunk-RQYXNWWN.mjs.map
+//# sourceMappingURL=chunk-KNC7XYT6.mjs.map