@dxos/react-ui-table 0.8.4-main.c1de068 → 0.8.4-main.e098934

package/dist/lib/node-esm/index.mjs

@@ -8,7 +8,6 @@ import {
   TableModel,
   TablePresentation,
   cellClassesForRowSelection,
-  createTable,
   getBaseSchema,
   makeDynamicTable,
   narrowSchema,
@@ -17,8 +16,8 @@ import {
   touch,
   useAddRow,
   useTableModel
-} from "./chunk-Y66YLSTC.mjs";
-import "./chunk-NXZ4CJYX.mjs";
+} from "./chunk-RNQDU7IQ.mjs";
+import "./chunk-K734DJB7.mjs";
 
 // src/translations.ts
 var translationKey = "react-ui-table";
@@ -30,8 +29,8 @@ var translations = [
         "create object label": "Create table",
         "table name placeholder": "Table name",
         "settings title": "Table settings",
-        "table schema label": "Schema",
-        "new schema": "New schema",
+        "table schema label": "Record type",
+        "new schema": "New record type",
         "continue label": "Continue",
         "create stack section label": "Create table",
         "add row label": "Add row",
@@ -54,270 +53,37 @@ var translations = [
 
 // src/components/Table/Table.tsx
 import { useSignals as _useSignals8 } from "@preact-signals/safe-react/tracking";
-import React8, { forwardRef, useCallback as useCallback5, useImperativeHandle, useState as useState4, useMemo as useMemo5, useEffect as useEffect4 } from "react";
-import { Filter } from "@dxos/echo";
-import { getValue } from "@dxos/echo-schema";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { getSpace as getSpace2 } from "@dxos/react-client/echo";
-import { useTranslation as useTranslation3 } from "@dxos/react-ui";
+import React8, { forwardRef, useCallback as useCallback5, useEffect as useEffect3, useImperativeHandle, useMemo as useMemo5, useState as useState4 } from "react";
 import { useAttention } from "@dxos/react-ui-attention";
-import { closestCell, Grid, gridSeparatorInlineEnd, gridSeparatorBlockEnd } from "@dxos/react-ui-grid";
+import { Grid, closestCell, gridSeparatorBlockEnd, gridSeparatorInlineEnd } from "@dxos/react-ui-grid";
+import { DxEditRequest } from "@dxos/react-ui-grid";
 import { mx } from "@dxos/react-ui-theme";
-import { isNotFalsy, safeParseInt } from "@dxos/util";
-
-// src/components/Table/ColumnActionsMenu.tsx
-import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
-import React from "react";
-import { DropdownMenu, useTranslation } from "@dxos/react-ui";
-var ColumnActionsMenu = ({ model, modals }) => {
-  var _effect = _useSignals();
-  try {
-    const { t } = useTranslation(translationKey);
-    const state = modals.state.value;
-    if (state?.type !== "column") {
-      return null;
-    }
-    const currentSort = model.sorting?.sorting;
-    const isCurrentColumnSorted = currentSort?.fieldId === state.fieldId;
-    return /* @__PURE__ */ React.createElement(DropdownMenu.Root, {
-      modal: false,
-      open: true,
-      onOpenChange: modals.close
-    }, /* @__PURE__ */ React.createElement(DropdownMenu.VirtualTrigger, {
-      virtualRef: modals.trigger
-    }), /* @__PURE__ */ React.createElement(DropdownMenu.Portal, null, /* @__PURE__ */ React.createElement(DropdownMenu.Content, null, /* @__PURE__ */ React.createElement(DropdownMenu.Viewport, null, (!isCurrentColumnSorted || currentSort?.direction === "asc") && /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
-      "data-testid": "column-sort-descending",
-      onClick: () => model.sorting?.setSort(state.fieldId, "desc")
-    }, t("column action sort descending")), (!isCurrentColumnSorted || currentSort?.direction === "desc") && /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
-      "data-testid": "column-sort-ascending",
-      onClick: () => model.sorting?.setSort(state.fieldId, "asc")
-    }, t("column action sort ascending")), isCurrentColumnSorted && /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
-      "data-testid": "column-clear-sort",
-      onClick: () => model.sorting?.clearSort()
-    }, t("column action clear sorting")), model.getColumnCount() > 1 && model.features.schemaEditable && /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
-      "data-testid": "column-delete",
-      onClick: () => model.deleteColumn(state.fieldId)
-    }, t("column action delete")), model.features.schemaEditable && /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
-      "data-testid": "column-settings",
-      onClick: () => modals.openColumnSettings()
-    }, t("column action settings"))), /* @__PURE__ */ React.createElement(DropdownMenu.Arrow, null))));
-  } finally {
-    _effect.f();
-  }
-};
-
-// src/components/Table/ColumnSettings.tsx
-import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
-import React2, { useCallback, useEffect, useMemo, useState } from "react";
-import { Popover } from "@dxos/react-ui";
-import { FieldEditor } from "@dxos/react-ui-form";
-var ColumnSettings = ({ registry, model, modals, onNewColumn }) => {
-  var _effect = _useSignals2();
-  try {
-    const [newField, setNewField] = useState();
-    const state = modals.state.value;
-    useEffect(() => {
-      if (state?.type === "columnSettings" && state.mode.type === "create" && model?.projection) {
-        setNewField(model.projection.createFieldProjection());
-        requestAnimationFrame(() => {
-          onNewColumn();
-        });
-      } else {
-        setNewField(void 0);
-      }
-    }, [
-      model?.projection,
-      state
-    ]);
-    const existingField = useMemo(() => {
-      if (state?.type === "columnSettings") {
-        const { mode } = state;
-        if (mode.type === "edit") {
-          return model?.projection?.fields.find((f) => f.id === mode.fieldId);
-        }
-      }
-      return void 0;
-    }, [
-      model?.projection?.fields,
-      state
-    ]);
-    const field = existingField ?? newField;
-    const handleSave = useCallback(() => {
-      modals.close();
-    }, [
-      modals
-    ]);
-    const handleCancel = useCallback(() => {
-      if (state?.type === "columnSettings" && state.mode.type === "create" && newField) {
-        model?.projection.deleteFieldProjection(newField.id);
-      }
-    }, [
-      model?.projection,
-      state,
-      newField
-    ]);
-    if (!model?.projection || !field) {
-      return null;
-    }
-    return /* @__PURE__ */ React2.createElement(Popover.Root, {
-      modal: false,
-      open: state?.type === "columnSettings"
-    }, /* @__PURE__ */ React2.createElement(Popover.VirtualTrigger, {
-      virtualRef: modals.trigger
-    }), /* @__PURE__ */ React2.createElement(Popover.Portal, null, /* @__PURE__ */ React2.createElement(Popover.Content, {
-      classNames: "md:is-64"
-    }, /* @__PURE__ */ React2.createElement(Popover.Viewport, null, /* @__PURE__ */ React2.createElement(FieldEditor, {
-      projection: model.projection,
-      field,
-      registry,
-      onSave: handleSave,
-      onCancel: handleCancel
-    })), /* @__PURE__ */ React2.createElement(Popover.Arrow, null))));
-  } finally {
-    _effect.f();
-  }
-};
-
-// src/components/Table/CreateRefPanel.tsx
-import { useSignals as _useSignals3 } from "@preact-signals/safe-react/tracking";
-import { Schema } from "effect";
-import React3, { useCallback as useCallback2, useMemo as useMemo2 } from "react";
-import { live } from "@dxos/live-object";
-import { getSpace } from "@dxos/react-client/echo";
-import { Popover as Popover2 } from "@dxos/react-ui";
-import { Form } from "@dxos/react-ui-form";
-import { useGridContext } from "@dxos/react-ui-grid";
-var CreateRefPanel = ({ model, modals, __gridScope }) => {
-  var _effect = _useSignals3();
-  try {
-    const { id: gridId } = useGridContext("TableCellEditor", __gridScope);
-    const space = model && getSpace(model?.view);
-    const state = modals.state.value;
-    const schema = useMemo2(() => {
-      if (!space || state?.type !== "createRefPanel") {
-        return;
-      }
-      const [schema2] = space.db.schemaRegistry.query({
-        typename: state.typename
-      }).runSync();
-      if (schema2) {
-        const omit = Schema.omit("id");
-        return omit(schema2);
-      }
-    }, [
-      space,
-      state
-    ]);
-    const handleSave = useCallback2((values) => {
-      if (!model || !space || state?.type !== "createRefPanel") {
-        return;
-      }
-      const [schema2] = space.db.schemaRegistry.query({
-        typename: state.typename
-      }).runSync();
-      if (schema2) {
-        const obj = space.db.add(live(schema2, values));
-        state.onCreate?.(obj);
-      }
-      void modals.close();
-    }, [
-      modals,
-      space,
-      state
-    ]);
-    const handleCancel = useCallback2(() => {
-      if (model) {
-        modals.close();
-      }
-    }, [
-      modals
-    ]);
-    if (!model?.projection) {
-      return null;
-    }
-    return /* @__PURE__ */ React3.createElement(Popover2.Root, {
-      modal: false,
-      open: state?.type === "createRefPanel" && !!schema,
-      onOpenChange: (nextOpen) => {
-        if (model && !nextOpen) {
-          return modals.close();
-        }
-      }
-    }, /* @__PURE__ */ React3.createElement(Popover2.VirtualTrigger, {
-      virtualRef: modals.trigger
-    }), /* @__PURE__ */ React3.createElement(Popover2.Portal, null, /* @__PURE__ */ React3.createElement(Popover2.Content, {
-      classNames: "md:is-64",
-      "data-grid": gridId
-    }, /* @__PURE__ */ React3.createElement(Popover2.Viewport, null, state?.type === "createRefPanel" && schema && /* @__PURE__ */ React3.createElement(Form, {
-      schema,
-      values: state.initialValues ?? {},
-      onSave: handleSave,
-      onCancel: handleCancel
-    })), /* @__PURE__ */ React3.createElement(Popover2.Arrow, null))));
-  } finally {
-    _effect.f();
-  }
-};
-
-// src/components/Table/RowActionsMenu.tsx
-import { useSignals as _useSignals4 } from "@preact-signals/safe-react/tracking";
-import React4 from "react";
-import { DropdownMenu as DropdownMenu2, useTranslation as useTranslation2 } from "@dxos/react-ui";
-var RowActionsMenu = ({ model, modals }) => {
-  var _effect = _useSignals4();
-  try {
-    const { t } = useTranslation2(translationKey);
-    const hasSelection = model.selection.hasSelection.value;
-    const state = modals.state.value;
-    if (state?.type !== "row") {
-      return null;
-    }
-    return /* @__PURE__ */ React4.createElement(DropdownMenu2.Root, {
-      modal: false,
-      open: true,
-      onOpenChange: modals.close
-    }, /* @__PURE__ */ React4.createElement(DropdownMenu2.VirtualTrigger, {
-      virtualRef: modals.trigger
-    }), /* @__PURE__ */ React4.createElement(DropdownMenu2.Content, null, /* @__PURE__ */ React4.createElement(DropdownMenu2.Viewport, null, model.features.dataEditable !== false && /* @__PURE__ */ React4.createElement(DropdownMenu2.Item, {
-      "data-testid": "row-menu-delete",
-      onClick: () => model.deleteRow(state.rowIndex)
-    }, t(hasSelection ? "bulk delete row label" : "delete row label")), model.rowActions?.map((action) => /* @__PURE__ */ React4.createElement(DropdownMenu2.Item, {
-      key: action.id,
-      "data-testid": `row-action-${action.id}`,
-      onClick: () => {
-        modals.close();
-        model.handleRowAction(action.id, state.rowIndex);
-      }
-    }, t(action.translationKey)))), /* @__PURE__ */ React4.createElement(DropdownMenu2.Arrow, null)));
-  } finally {
-    _effect.f();
-  }
-};
 
 // src/components/TableCellEditor/TableCellEditor.tsx
-import { useSignals as _useSignals7 } from "@preact-signals/safe-react/tracking";
-import React7, { useCallback as useCallback4, useEffect as useEffect3, useMemo as useMemo4, useRef as useRef2, useState as useState3 } from "react";
+import { useSignals as _useSignals3 } from "@preact-signals/safe-react/tracking";
+import { EditorView } from "@codemirror/view";
+import React3, { useCallback as useCallback2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+import { debounce } from "@dxos/async";
 import { FormatEnum, TypeEnum } from "@dxos/echo-schema";
 import { invariant as invariant2 } from "@dxos/invariant";
-import { useThemeContext } from "@dxos/react-ui";
 import { createMarkdownExtensions } from "@dxos/react-ui-editor";
-import { cellQuery, editorKeys, parseCellIndex as parseCellIndex2, useGridContext as useGridContext4, GridCellEditor } from "@dxos/react-ui-grid";
-import { tagPicker, createLinks } from "@dxos/react-ui-tag-picker";
+import { GridCellEditor, editorKeys, parseCellIndex as parseCellIndex2, useGridContext as useGridContext3 } from "@dxos/react-ui-grid";
+import { createLinks, tagPicker } from "@dxos/react-ui-tag-picker";
 
 // src/components/TableCellEditor/CellValidationMessage.tsx
-import { useSignals as _useSignals5 } from "@preact-signals/safe-react/tracking";
-import React5 from "react";
-import { useGridContext as useGridContext2 } from "@dxos/react-ui-grid";
+import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
+import React from "react";
+import { useGridContext } from "@dxos/react-ui-grid";
 var CellValidationMessage = ({ validationError, variant = "error", __gridScope }) => {
-  var _effect = _useSignals5();
+  var _effect = _useSignals();
   try {
-    const { editing, editBox: box } = useGridContext2("GridSheetCellEditor", __gridScope);
+    const { editing, editBox: box } = useGridContext("GridSheetCellEditor", __gridScope);
     if (!editing || !validationError) {
       return null;
     }
     const bgClass = variant === "error" ? "bg-errorSurface" : "bg-warningSurface";
     const textClass = variant === "error" ? "text-errorSurfaceText" : "text-warningSurfaceText";
-    return /* @__PURE__ */ React5.createElement("div", {
+    return /* @__PURE__ */ React.createElement("div", {
       role: "none",
       className: `absolute ${bgClass} ${textClass} rounded-bs-sm text-xs p-1`,
       style: {
@@ -336,71 +102,107 @@ var CellValidationMessage = ({ validationError, variant = "error", __gridScope }
 };
 
 // src/components/TableCellEditor/FormCellEditor.tsx
-import { useSignals as _useSignals6 } from "@preact-signals/safe-react/tracking";
-import React6, { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo3, useRef, useState as useState2 } from "react";
-import { getSnapshot } from "@dxos/echo-schema";
+import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
+import React2, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Filter, Obj } from "@dxos/echo";
+import { Ref, getValue } from "@dxos/echo-schema";
 import { invariant } from "@dxos/invariant";
-import { Popover as Popover3 } from "@dxos/react-ui";
-import { Form as Form2 } from "@dxos/react-ui-form";
-import { parseCellIndex, useGridContext as useGridContext3 } from "@dxos/react-ui-grid";
-import { getDeep, setDeep } from "@dxos/util";
+import { getSnapshot } from "@dxos/live-object";
+import { getSpace } from "@dxos/react-client/echo";
+import { Popover } from "@dxos/react-ui";
+import { Form } from "@dxos/react-ui-form";
+import { cellQuery, parseCellIndex, useGridContext as useGridContext2 } from "@dxos/react-ui-grid";
+import { getDeep, isNotFalsy, setDeep } from "@dxos/util";
 var __dxlog_file = "/__w/dxos/dxos/packages/ui/react-ui-table/src/components/TableCellEditor/FormCellEditor.tsx";
-var FormCellEditor = ({ fieldProjection, model, schema, onSave, __gridScope }) => {
-  var _effect = _useSignals6();
+var createOptionLabel = [
+  "create new object label",
+  {
+    ns: translationKey
+  }
+];
+var FormCellEditor = ({ fieldProjection, model, schema, onSave, client, modals, __gridScope, ...formProps }) => {
+  var _effect = _useSignals2();
   try {
-    const { editing: contextEditing, setEditing } = useGridContext3("ArrayEditor", __gridScope);
-    const [editing, setLocalEditing] = useState2(false);
+    const { editing: contextEditing, setEditing, id: gridId } = useGridContext2("ArrayEditor", __gridScope);
+    const [editing, setLocalEditing] = useState(false);
     const anchorRef = useRef(null);
-    useEffect2(() => {
-      if (contextEditing && contextEditing.cellElement) {
-        anchorRef.current = contextEditing.cellElement.querySelector(".dx-grid__cell__content");
-        setLocalEditing(true);
-      } else {
-        anchorRef.current = null;
-        setLocalEditing(false);
+    const getSchema = useCallback((typeAnnotation) => {
+      const space = getSpace(model.view);
+      invariant(space, void 0, {
+        F: __dxlog_file,
+        L: 53,
+        S: void 0,
+        A: [
+          "space",
+          ""
+        ]
+      });
+      let schema2;
+      if (client) {
+        schema2 = client.graph.schemaRegistry.getSchema(typeAnnotation.typename);
+      }
+      if (!schema2) {
+        schema2 = space.db.schemaRegistry.getSchema(typeAnnotation.typename);
       }
+      return {
+        space,
+        schema: schema2
+      };
     }, [
-      contextEditing
+      client,
+      model
     ]);
-    const narrowedSchema = useMemo3(() => {
-      if (!schema) {
-        return void 0;
+    const handleQueryRefOptions = useCallback(async (typeAnnotation) => {
+      const { schema: schema2, space } = getSchema(typeAnnotation);
+      if (model && schema2 && space) {
+        const { objects } = await space.db.query(Filter.type(schema2)).run();
+        return objects.map((obj) => {
+          return {
+            dxn: Obj.getDXN(obj),
+            label: getValue(obj, fieldProjection.field.referencePath) || obj.id.toString()
+          };
+        }).filter(isNotFalsy);
       }
-      return narrowSchema(schema, [
-        fieldProjection.field.path
-      ]);
+      return [];
     }, [
-      JSON.stringify(schema),
-      fieldProjection.field.path
+      client,
+      model
     ]);
-    const originalRow = useMemo3(() => {
+    const originalRow = useMemo(() => {
       if (model && contextEditing) {
         const cell = parseCellIndex(contextEditing.index);
-        const row = model.getRowAt(cell.row);
-        invariant(row, void 0, {
-          F: __dxlog_file,
-          L: 55,
-          S: void 0,
-          A: [
-            "row",
-            ""
-          ]
-        });
-        return row;
+        if (model.isDraftCell(cell)) {
+          const draftRow = model.draftRows.value[cell.row];
+          invariant(draftRow, void 0, {
+            F: __dxlog_file,
+            L: 94,
+            S: void 0,
+            A: [
+              "draftRow",
+              ""
+            ]
+          });
+          return draftRow.data;
+        } else {
+          const row = model.getRowAt(cell.row);
+          invariant(row, void 0, {
+            F: __dxlog_file,
+            L: 98,
+            S: void 0,
+            A: [
+              "row",
+              ""
+            ]
+          });
+          return row;
+        }
       }
       return void 0;
     }, [
       model,
       contextEditing
     ]);
-    const formValues = useMemo3(() => {
-      if (originalRow) {
-        return getSnapshot(originalRow);
-      }
-    }, [
-      originalRow
-    ]);
-    const handleSave = useCallback3((values) => {
+    const handleSave = useCallback((values) => {
       const path = fieldProjection.field.path;
       const value = getDeep(values, [
         path
@@ -408,14 +210,74 @@ var FormCellEditor = ({ fieldProjection, model, schema, onSave, __gridScope }) =
       setDeep(originalRow, [
         path
       ], value);
+      contextEditing?.cellElement?.focus();
       setEditing(null);
       setLocalEditing(false);
       onSave?.();
     }, [
       fieldProjection.field.path,
+      onSave,
+      contextEditing,
+      originalRow
+    ]);
+    const handleCreate = useCallback((object) => {
+      const ref = Ref.make(object);
+      const path = fieldProjection.field.path;
+      setDeep(originalRow, [
+        path
+      ], ref);
+      contextEditing?.cellElement?.focus();
+      setEditing(null);
+      setLocalEditing(false);
+      onSave?.();
+    }, [
+      fieldProjection.field.path,
+      onSave,
+      contextEditing,
+      originalRow
+    ]);
+    const handleCreateFromQuery = useCallback(async (typeAnnotation, query) => {
+      if (model && modals && contextEditing?.index) {
+        setLocalEditing(false);
+        modals.openCreateRef(typeAnnotation.typename, document.querySelector(cellQuery(contextEditing.index, gridId)), {
+          [fieldProjection.field.referencePath]: query
+        }, handleCreate);
+      }
+    }, [
+      model,
+      modals,
+      client,
+      contextEditing?.index,
+      gridId,
+      fieldProjection,
+      handleSave
+    ]);
+    useEffect(() => {
+      if (contextEditing && contextEditing.cellElement) {
+        anchorRef.current = contextEditing.cellElement.querySelector(".dx-grid__cell__content");
+        setLocalEditing(true);
+      } else {
+        anchorRef.current = null;
+        setLocalEditing(false);
+      }
+    }, [
+      contextEditing
+    ]);
+    const narrowedSchema = useMemo(() => {
+      if (!schema) {
+        return void 0;
+      }
+      return narrowSchema(schema, [
+        fieldProjection.field.path
+      ]);
+    }, [
+      JSON.stringify(schema),
+      fieldProjection.field.path
+    ]);
+    const formValues = useMemo(() => originalRow ? getSnapshot(originalRow) : {}, [
       originalRow
     ]);
-    const handleOpenChange = useCallback3((nextOpen) => {
+    const handleOpenChange = useCallback((nextOpen) => {
       if (nextOpen === false) {
         setEditing(null);
         onSave?.();
@@ -425,76 +287,38 @@ var FormCellEditor = ({ fieldProjection, model, schema, onSave, __gridScope }) =
     if (!editing) {
       return null;
     }
-    return /* @__PURE__ */ React6.createElement(Popover3.Root, {
+    return /* @__PURE__ */ React2.createElement(Popover.Root, {
       open: editing,
       onOpenChange: handleOpenChange
-    }, /* @__PURE__ */ React6.createElement(Popover3.VirtualTrigger, {
+    }, /* @__PURE__ */ React2.createElement(Popover.VirtualTrigger, {
       virtualRef: anchorRef
-    }), /* @__PURE__ */ React6.createElement(Popover3.Content, {
+    }), /* @__PURE__ */ React2.createElement(Popover.Portal, null, /* @__PURE__ */ React2.createElement(Popover.Content, {
       tabIndex: -1,
       classNames: "popover-card-width density-fine"
-    }, /* @__PURE__ */ React6.createElement(Popover3.Arrow, null), /* @__PURE__ */ React6.createElement(Popover3.Viewport, null, /* @__PURE__ */ React6.createElement(Form2, {
+    }, /* @__PURE__ */ React2.createElement(Popover.Arrow, null), /* @__PURE__ */ React2.createElement(Popover.Viewport, null, /* @__PURE__ */ React2.createElement(Form, {
+      autoFocus: true,
       values: formValues,
       schema: narrowedSchema,
-      onSave: handleSave
-    }))));
+      onSave: handleSave,
+      ...formProps,
+      onQueryRefOptions: handleQueryRefOptions,
+      onCreateFromQuery: handleCreateFromQuery,
+      createOptionIcon: "ph--plus--regular",
+      createOptionLabel
+    })))));
   } finally {
     _effect.f();
   }
 };
 
-// src/components/TableCellEditor/extension.ts
-import { autocompletion, pickedCompletion } from "@codemirror/autocomplete";
-import { EditorView } from "@codemirror/view";
-var completion = ({ debug, onQuery, onMatch }) => {
-  return [
-    EditorView.theme({
-      ".cm-completionDialog": {
-        width: "var(--dx-gridCellWidth)"
-      }
-    }),
-    autocompletion({
-      icons: false,
-      activateOnTyping: true,
-      closeOnBlur: !debug,
-      override: [
-        async (context) => {
-          const text = context.state.doc.toString();
-          return {
-            from: 0,
-            options: await onQuery(text)
-          };
-        }
-      ],
-      // TODO(burdon): Consts from grid (to line-up with grid).
-      tooltipClass: () => "cm-completionDialog !mt-[8px] !-ml-[4px] [&>ul]:!max-h-[264px]",
-      optionClass: () => "flex h-[33px] items-center"
-    }),
-    // Check for accepted completion metadata in the transaction.
-    EditorView.updateListener.of((update) => {
-      update.transactions.forEach((tr) => {
-        const completion2 = tr.annotation(pickedCompletion);
-        if (completion2) {
-          onMatch(completion2.data);
-        }
-      });
-    })
-  ];
-};
-
 // src/components/TableCellEditor/TableCellEditor.tsx
 var __dxlog_file2 = "/__w/dxos/dxos/packages/ui/react-ui-table/src/components/TableCellEditor/TableCellEditor.tsx";
-var newValue = Symbol.for("newValue");
-var createOption = (text) => ({
-  [newValue]: true,
-  text
-});
-var isCreateOption = (data) => typeof data === "object" && data[newValue];
-var TableValueEditor = ({ model, modals, schema, onEnter, onFocus, onSave, onQuery, __gridScope }) => {
-  var _effect = _useSignals7();
+var adaptValidationMessage = (message) => message ? message.endsWith("is missing") ? "Can\u2019t be blank" : message : null;
+var TableValueEditor = ({ model, modals, schema, onFocus, onSave, client, __gridScope }) => {
+  var _effect = _useSignals3();
   try {
-    const { editing } = useGridContext4("TableValueEditor", __gridScope);
-    const fieldProjection = useMemo4(() => {
+    const { editing } = useGridContext3("TableValueEditor", __gridScope);
+    const fieldProjection = useMemo2(() => {
       if (!model || !editing) {
         return;
       }
@@ -503,7 +327,7 @@ var TableValueEditor = ({ model, modals, schema, onEnter, onFocus, onSave, onQue
       const fieldProjection2 = model.projection.getFieldProjection(field.id);
       invariant2(fieldProjection2, void 0, {
         F: __dxlog_file2,
-        L: 76,
+        L: 71,
         S: void 0,
         A: [
           "fieldProjection",
@@ -515,21 +339,21 @@ var TableValueEditor = ({ model, modals, schema, onEnter, onFocus, onSave, onQue
       model,
       editing
     ]);
-    if (fieldProjection?.props.type === TypeEnum.Array || fieldProjection?.props.format === FormatEnum.SingleSelect) {
-      return /* @__PURE__ */ React7.createElement(FormCellEditor, {
+    if (fieldProjection?.props.type === TypeEnum.Array || fieldProjection?.props.format === FormatEnum.SingleSelect || fieldProjection?.props.format === FormatEnum.Ref) {
+      return /* @__PURE__ */ React3.createElement(FormCellEditor, {
         fieldProjection,
         model,
         schema,
         __gridScope,
-        onSave
+        onSave,
+        client,
+        modals
       });
     }
-    return /* @__PURE__ */ React7.createElement(TableCellEditor, {
+    return /* @__PURE__ */ React3.createElement(TableCellEditor, {
       model,
       modals,
-      onEnter,
       onFocus,
-      onQuery,
       onSave,
       __gridScope
     });
@@ -538,19 +362,18 @@ var TableValueEditor = ({ model, modals, schema, onEnter, onFocus, onSave, onQue
   }
 };
 var editorSlots = {
-  scroller: {
+  scroll: {
     className: "!plb-[--dx-grid-cell-editor-padding-block]"
   }
 };
-var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gridScope }) => {
-  var _effect = _useSignals7();
+var TableCellEditor = ({ model, modals, onFocus, onSave, __gridScope }) => {
+  var _effect = _useSignals3();
   try {
-    const { id: gridId, editing, setEditing } = useGridContext4("TableCellEditor", __gridScope);
+    const { editing, setEditing } = useGridContext3("TableCellEditor", __gridScope);
     const suppressNextBlur = useRef2(false);
-    const { themeMode } = useThemeContext();
-    const [_validationError, setValidationError] = useState3(null);
-    const [_validationVariant, setValidationVariant] = useState3("error");
-    const fieldProjection = useMemo4(() => {
+    const [validationError, setValidationError] = useState2(null);
+    const [validationVariant, setValidationVariant] = useState2("error");
+    const fieldProjection = useMemo2(() => {
       if (!model || !editing) {
         return;
       }
@@ -559,7 +382,7 @@ var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gri
       const fieldProjection2 = model.projection.getFieldProjection(field.id);
       invariant2(fieldProjection2, void 0, {
         F: __dxlog_file2,
-        L: 135,
+        L: 120,
         S: void 0,
         A: [
           "fieldProjection",
@@ -571,38 +394,7 @@ var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gri
       model,
       editing
     ]);
-    useEffect3(() => {
-      if (!model || !editing || !fieldProjection) {
-        setValidationError(null);
-        return;
-      }
-      const cell = parseCellIndex2(editing.index);
-      const { row, col } = cell;
-      if (model.isDraftCell(cell)) {
-        const field = model.projection.fields[col];
-        const hasValidationError = model.hasDraftRowValidationError(row, field.path);
-        if (hasValidationError) {
-          const draftRows = model.draftRows.value;
-          if (row >= 0 && row < draftRows.length) {
-            const draftRow = draftRows[row];
-            const validationError = draftRow.validationErrors?.find((error) => error.path === field.path);
-            if (validationError) {
-              setValidationError(validationError.message);
-              setValidationVariant("warning");
-            }
-          }
-        } else {
-          setValidationError(null);
-        }
-      } else {
-        setValidationError(null);
-      }
-    }, [
-      model,
-      editing,
-      fieldProjection
-    ]);
-    const handleEnter = useCallback4(async (value) => {
+    const handleEnter = useCallback2(async (value) => {
       if (!model || !editing) {
         return;
       }
@@ -611,33 +403,39 @@ var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gri
       if (validationResult.valid) {
         setValidationError(null);
         model.setCellData(cell, value);
-        onEnter?.(cell);
         onFocus?.();
         setEditing(null);
         onSave?.();
       } else {
-        setValidationError(validationResult.error);
+        setValidationError(adaptValidationMessage(validationResult.error));
         setValidationVariant("error");
       }
     }, [
       model,
       editing,
-      onEnter,
       onFocus,
       setEditing
     ]);
-    const handleBlur = useCallback4(async (value) => {
-      if (!model || !editing) {
-        return;
-      }
+    const handleBlur = useCallback2(async (value) => {
       if (suppressNextBlur.current) {
         suppressNextBlur.current = false;
+      } else if (model && editing) {
+        const cell = parseCellIndex2(editing.index);
+        if (value !== void 0) {
+          const result = await model.validateCellData(cell, value);
+          if (result.valid) {
+            setValidationError(null);
+            model.setCellData(cell, value);
+            setEditing(null);
+            onSave?.();
+          }
+        }
       }
     }, [
       model,
       editing
     ]);
-    const handleClose = useCallback4(async (value, event) => {
+    const handleClose = useCallback2(async (value, event) => {
       if (!model || !editing || !fieldProjection) {
         return;
       }
@@ -645,19 +443,20 @@ var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gri
       if (value !== void 0) {
         const result = await model.validateCellData(cell, value);
         if (result.valid) {
+          suppressNextBlur.current = true;
           setValidationError(null);
           model.setCellData(cell, value);
           setEditing(null);
           onSave?.();
-          onEnter?.(cell);
           if (event && onFocus) {
-            onFocus(determineNavigationAxis(event), determineNavigationDelta(event));
+            onFocus(determineNavigationAxis(event), determineNavigationDelta(event), cell);
           }
         } else {
           setValidationError(result.error);
           setValidationVariant("error");
         }
       } else {
+        suppressNextBlur.current = true;
         setValidationError(null);
         setEditing(null);
         onSave?.();
@@ -666,182 +465,416 @@ var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gri
         }
       }
     }, [
-      model,
-      editing,
-      onFocus,
-      onEnter,
-      fieldProjection,
-      setEditing,
-      onSave
+      model,
+      editing,
+      onFocus,
+      fieldProjection,
+      setEditing,
+      onSave
+    ]);
+    const extensions = useMemo2(() => {
+      if (!fieldProjection) {
+        return [];
+      }
+      const extensions2 = [
+        editorKeys({
+          onClose: handleClose,
+          ...editing?.initialContent && {
+            onNav: handleClose
+          }
+        })
+      ];
+      const format = fieldProjection.props.format;
+      if (format === FormatEnum.SingleSelect || format === FormatEnum.MultiSelect) {
+        const options = fieldProjection.props.options || [];
+        const mode = format === FormatEnum.SingleSelect ? "single-select" : "multi-select";
+        extensions2.push(createMarkdownExtensions());
+        extensions2.push(tagPicker({
+          mode,
+          keymap: false,
+          onSearch: (text, selectedIds) => {
+            return options.filter((option) => selectedIds.indexOf(option.id) === -1 && (text.length === 0 || option.title.toLowerCase().includes(text.toLowerCase()))).map((option) => ({
+              id: option.id,
+              label: option.title,
+              hue: option.color
+            }));
+          },
+          onUpdate: (ids) => {
+            if (model && editing) {
+              if (ids.length === 0) {
+                return;
+              }
+              if (mode === "single-select") {
+                void handleEnter(ids[0]);
+              } else {
+                void handleEnter(ids);
+              }
+            }
+          }
+        }));
+      }
+      if (model && editing) {
+        extensions2.push(EditorView.updateListener.of(debounce((update) => {
+          const content = update.state.doc.toString();
+          const cell = parseCellIndex2(editing.index);
+          void model.validateCellData(cell, content).then((result) => {
+            if (result.valid) {
+              setValidationError(null);
+            } else {
+              setValidationError(result.error);
+              setValidationVariant("error");
+            }
+          });
+        }, 10)));
+      }
+      return extensions2;
+    }, [
+      model,
+      modals,
+      editing,
+      fieldProjection,
+      handleClose
+    ]);
+    const getCellContent = useCallback2(() => {
+      if (model && editing) {
+        const cell = parseCellIndex2(editing.index);
+        const { col } = cell;
+        const field = model.projection.fields[col];
+        const fieldProjection2 = model.projection.getFieldProjection(field.id);
+        if (fieldProjection2?.props.format === FormatEnum.SingleSelect || fieldProjection2?.props.format === FormatEnum.MultiSelect) {
+          const value2 = model.getCellData(cell);
+          if (value2 !== void 0) {
+            const options = fieldProjection2.props.options || [];
+            if (fieldProjection2.props.format === FormatEnum.MultiSelect) {
+              const tagItems = value2.split(",").map((id) => {
+                const option = options.find((o) => o.id === id);
+                if (option) {
+                  return {
+                    id,
+                    label: option.title,
+                    hue: option.color
+                  };
+                }
+                return void 0;
+              }).filter((item) => item !== void 0);
+              return createLinks(tagItems);
+            } else {
+              const option = options.find((o) => o.id === value2);
+              if (option) {
+                const tagItem = {
+                  id: value2,
+                  label: option.title,
+                  hue: option.color
+                };
+                return createLinks([
+                  tagItem
+                ]);
+              }
+            }
+          }
+          return "";
+        }
+        const value = model.getCellData(cell);
+        return value !== void 0 ? String(value) : "";
+      }
+    }, [
+      model,
+      editing
+    ]);
+    return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(CellValidationMessage, {
+      validationError,
+      variant: validationVariant,
+      __gridScope
+    }), /* @__PURE__ */ React3.createElement(GridCellEditor, {
+      extensions,
+      getCellContent,
+      onBlur: handleBlur,
+      slots: editorSlots
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+var determineNavigationAxis = ({ key }) => {
+  switch (key) {
+    case "ArrowUp":
+    case "ArrowDown":
+    case "Enter": {
+      return "row";
+    }
+    case "ArrowLeft":
+    case "ArrowRight":
+    case "Tab":
+      return "col";
+  }
+};
+var determineNavigationDelta = ({ key, shift }) => {
+  switch (key) {
+    case "ArrowUp":
+    case "ArrowLeft":
+      return -1;
+    case "ArrowDown":
+    case "ArrowRight":
+      return 1;
+  }
+  return shift ? -1 : 1;
+};
+
+// src/components/Table/ColumnActionsMenu.tsx
+import { useSignals as _useSignals4 } from "@preact-signals/safe-react/tracking";
+import React4 from "react";
+import { DropdownMenu, useTranslation } from "@dxos/react-ui";
+var ColumnActionsMenu = ({ model, modals }) => {
+  var _effect = _useSignals4();
+  try {
+    const { t } = useTranslation(translationKey);
+    const state = modals.state.value;
+    if (state?.type !== "column") {
+      return null;
+    }
+    const currentSort = model.sorting?.sorting;
+    const isCurrentColumnSorted = currentSort?.fieldId === state.fieldId;
+    return /* @__PURE__ */ React4.createElement(DropdownMenu.Root, {
+      modal: false,
+      open: true,
+      onOpenChange: modals.close
+    }, /* @__PURE__ */ React4.createElement(DropdownMenu.VirtualTrigger, {
+      virtualRef: modals.trigger
+    }), /* @__PURE__ */ React4.createElement(DropdownMenu.Portal, null, /* @__PURE__ */ React4.createElement(DropdownMenu.Content, null, /* @__PURE__ */ React4.createElement(DropdownMenu.Viewport, null, (!isCurrentColumnSorted || currentSort?.direction === "asc") && /* @__PURE__ */ React4.createElement(DropdownMenu.Item, {
+      "data-testid": "column-sort-descending",
+      onClick: () => model.sorting?.setSort(state.fieldId, "desc")
+    }, t("column action sort descending")), (!isCurrentColumnSorted || currentSort?.direction === "desc") && /* @__PURE__ */ React4.createElement(DropdownMenu.Item, {
+      "data-testid": "column-sort-ascending",
+      onClick: () => model.sorting?.setSort(state.fieldId, "asc")
+    }, t("column action sort ascending")), isCurrentColumnSorted && /* @__PURE__ */ React4.createElement(DropdownMenu.Item, {
+      "data-testid": "column-clear-sort",
+      onClick: () => model.sorting?.clearSort()
+    }, t("column action clear sorting")), model.getColumnCount() > 1 && model.features.schemaEditable && /* @__PURE__ */ React4.createElement(DropdownMenu.Item, {
+      "data-testid": "column-delete",
+      onClick: () => model.deleteColumn(state.fieldId)
+    }, t("column action delete")), model.features.schemaEditable && /* @__PURE__ */ React4.createElement(DropdownMenu.Item, {
+      "data-testid": "column-settings",
+      onClick: () => modals.openColumnSettings()
+    }, t("column action settings"))), /* @__PURE__ */ React4.createElement(DropdownMenu.Arrow, null))));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/Table/ColumnSettings.tsx
+import { useSignals as _useSignals5 } from "@preact-signals/safe-react/tracking";
+import React5, { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo3, useState as useState3 } from "react";
+import { Popover as Popover2 } from "@dxos/react-ui";
+import { FieldEditor } from "@dxos/react-ui-form";
+var ColumnSettings = ({ registry, model, modals, onNewColumn }) => {
+  var _effect = _useSignals5();
+  try {
+    const [newField, setNewField] = useState3();
+    const state = modals.state.value;
+    useEffect2(() => {
+      if (state?.type === "columnSettings" && state.mode.type === "create" && model?.projection) {
+        setNewField(model.projection.createFieldProjection());
+        requestAnimationFrame(() => {
+          onNewColumn();
+        });
+      } else {
+        setNewField(void 0);
+      }
+    }, [
+      model?.projection,
+      state
+    ]);
+    const existingField = useMemo3(() => {
+      if (state?.type === "columnSettings") {
+        const { mode } = state;
+        if (mode.type === "edit") {
+          return model?.projection?.fields.find((f) => f.id === mode.fieldId);
+        }
+      }
+      return void 0;
+    }, [
+      model?.projection?.fields,
+      state
+    ]);
+    const field = existingField ?? newField;
+    const handleSave = useCallback3(() => {
+      modals.close();
+    }, [
+      modals
+    ]);
+    const handleCancel = useCallback3(() => {
+      if (state?.type === "columnSettings" && state.mode.type === "create" && newField) {
+        model?.projection.deleteFieldProjection(newField.id);
+      }
+    }, [
+      model?.projection,
+      state,
+      newField
+    ]);
+    if (!model?.projection || !field) {
+      return null;
+    }
+    return /* @__PURE__ */ React5.createElement(Popover2.Root, {
+      modal: false,
+      open: state?.type === "columnSettings"
+    }, /* @__PURE__ */ React5.createElement(Popover2.VirtualTrigger, {
+      virtualRef: modals.trigger
+    }), /* @__PURE__ */ React5.createElement(Popover2.Portal, null, /* @__PURE__ */ React5.createElement(Popover2.Content, {
+      classNames: "md:is-64"
+    }, /* @__PURE__ */ React5.createElement(Popover2.Viewport, null, /* @__PURE__ */ React5.createElement(FieldEditor, {
+      projection: model.projection,
+      field,
+      registry,
+      onSave: handleSave,
+      onCancel: handleCancel
+    })), /* @__PURE__ */ React5.createElement(Popover2.Arrow, null))));
+  } finally {
+    _effect.f();
+  }
+};
+
+// src/components/Table/CreateRefPanel.tsx
+import { useSignals as _useSignals6 } from "@preact-signals/safe-react/tracking";
+import { Schema } from "effect";
+import React6, { useCallback as useCallback4, useMemo as useMemo4 } from "react";
+import { Type } from "@dxos/echo";
+import { live } from "@dxos/live-object";
+import { useClient } from "@dxos/react-client";
+import { getSpace as getSpace2 } from "@dxos/react-client/echo";
+import { Popover as Popover3 } from "@dxos/react-ui";
+import { Form as Form2 } from "@dxos/react-ui-form";
+import { useGridContext as useGridContext4 } from "@dxos/react-ui-grid";
+var CreateRefPanel = ({ model, modals, __gridScope }) => {
+  var _effect = _useSignals6();
+  try {
+    const { id: gridId } = useGridContext4("TableCellEditor", __gridScope);
+    const client = useClient();
+    const space = model && getSpace2(model?.view);
+    const state = modals.state.value;
+    const getSchema = useCallback4(() => {
+      if (!space || state?.type !== "createRefPanel") {
+        return;
+      }
+      const staticSchema = client.graph.schemaRegistry.schemas.find((schema3) => Type.getTypename(schema3) === state.typename);
+      if (staticSchema) {
+        return staticSchema;
+      }
+      const [schema2] = space.db.schemaRegistry.query({
+        typename: state.typename
+      }).runSync();
+      return schema2;
+    }, [
+      space,
+      state
+    ]);
+    const schema = useMemo4(() => {
+      const schema2 = getSchema();
+      if (!schema2) {
+        return;
+      }
+      const omit = Schema.omit("id");
+      return omit(schema2);
+    }, [
+      getSchema
     ]);
-    const extension = useMemo4(() => {
-      if (!fieldProjection) {
-        return [];
-      }
-      const extension2 = [
-        editorKeys({
-          onClose: handleClose,
-          ...editing?.initialContent && {
-            onNav: handleClose
-          }
-        })
-      ];
-      const format = fieldProjection.props.format;
-      if (format === FormatEnum.SingleSelect || format === FormatEnum.MultiSelect) {
-        extension2.push(createMarkdownExtensions({
-          themeMode
-        }));
-        const options = fieldProjection.props.options || [];
-        const mode = format === FormatEnum.SingleSelect ? "single-select" : "multi-select";
-        extension2.push(tagPicker({
-          mode,
-          keymap: false,
-          onSearch: (text, selectedIds) => {
-            return options.filter((option) => selectedIds.indexOf(option.id) === -1 && (text.length === 0 || option.title.toLowerCase().includes(text.toLowerCase()))).map((option) => ({
-              id: option.id,
-              label: option.title,
-              hue: option.color
-            }));
-          },
-          onUpdate: (ids) => {
-            if (model && editing) {
-              if (ids.length === 0) {
-                return;
-              }
-              if (mode === "single-select") {
-                void handleEnter(ids[0]);
-              } else {
-                void handleEnter(ids);
-              }
-            }
-          }
-        }));
+    const handleSave = useCallback4((values) => {
+      if (!model || !space || state?.type !== "createRefPanel") {
+        return;
       }
-      if (onQuery) {
-        switch (fieldProjection.props.format) {
-          case FormatEnum.Ref: {
-            extension2.push([
-              completion({
-                onQuery: (text) => onQuery(fieldProjection, text),
-                onMatch: (data) => {
-                  if (model && editing && modals) {
-                    if (isCreateOption(data)) {
-                      const { field, props } = fieldProjection;
-                      if (props.referenceSchema) {
-                        suppressNextBlur.current = true;
-                        modals.openCreateRef(props.referenceSchema, document.querySelector(cellQuery(editing.index, gridId)), {
-                          [field.referencePath]: data.text
-                        }, (data2) => {
-                          void handleEnter(data2);
-                        });
-                      }
-                    } else {
-                      void handleEnter(data);
-                    }
-                  }
-                }
-              })
-            ]);
-            break;
-          }
-        }
+      const schema2 = getSchema();
+      if (schema2) {
+        const obj = space.db.add(live(schema2, values));
+        state.onCreate?.(obj);
       }
-      return extension2;
+      void modals.close();
     }, [
       model,
       modals,
-      editing,
-      fieldProjection,
-      handleClose,
-      themeMode
+      space,
+      state
     ]);
-    const getCellContent = useCallback4(() => {
-      if (model && editing) {
-        const cell = parseCellIndex2(editing.index);
-        const { col } = cell;
-        const field = model.projection.fields[col];
-        const fieldProjection2 = model.projection.getFieldProjection(field.id);
-        if (fieldProjection2?.props.format === FormatEnum.SingleSelect || fieldProjection2?.props.format === FormatEnum.MultiSelect) {
-          const value2 = model.getCellData(cell);
-          if (value2 !== void 0) {
-            const options = fieldProjection2.props.options || [];
-            if (fieldProjection2.props.format === FormatEnum.MultiSelect) {
-              const tagItems = value2.split(",").map((id) => {
-                const option = options.find((o) => o.id === id);
-                if (option) {
-                  return {
-                    id,
-                    label: option.title,
-                    hue: option.color
-                  };
-                }
-                return void 0;
-              }).filter((item) => item !== void 0);
-              return createLinks(tagItems);
-            } else {
-              const option = options.find((o) => o.id === value2);
-              if (option) {
-                const tagItem = {
-                  id: value2,
-                  label: option.title,
-                  hue: option.color
-                };
-                return createLinks([
-                  tagItem
-                ]);
-              }
-            }
-          }
-          return "";
-        }
-        const value = model.getCellData(cell);
-        return value !== void 0 ? String(value) : "";
+    const handleCancel = useCallback4(() => {
+      if (model) {
+        modals.close();
       }
     }, [
-      model,
-      editing
+      modals
     ]);
-    return /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement(CellValidationMessage, {
-      validationError: _validationError,
-      variant: _validationVariant,
-      __gridScope
-    }), /* @__PURE__ */ React7.createElement(GridCellEditor, {
-      extension,
-      getCellContent,
-      onBlur: handleBlur,
-      slots: editorSlots
-    }));
+    if (!model?.projection) {
+      return null;
+    }
+    return /* @__PURE__ */ React6.createElement(Popover3.Root, {
+      modal: false,
+      open: state?.type === "createRefPanel" && !!schema,
+      onOpenChange: (nextOpen) => {
+        if (model && !nextOpen) {
+          return modals.close();
+        }
+      }
+    }, /* @__PURE__ */ React6.createElement(Popover3.VirtualTrigger, {
+      virtualRef: modals.trigger
+    }), /* @__PURE__ */ React6.createElement(Popover3.Portal, null, /* @__PURE__ */ React6.createElement(Popover3.Content, {
+      classNames: "md:is-64",
+      "data-grid": gridId
+    }, /* @__PURE__ */ React6.createElement(Popover3.Viewport, null, state?.type === "createRefPanel" && schema && /* @__PURE__ */ React6.createElement(Form2, {
+      schema,
+      values: state.initialValues ?? {},
+      onSave: handleSave,
+      onCancel: handleCancel
+    })), /* @__PURE__ */ React6.createElement(Popover3.Arrow, null))));
   } finally {
     _effect.f();
   }
 };
-var determineNavigationAxis = ({ key }) => {
-  switch (key) {
-    case "ArrowUp":
-    case "ArrowDown":
-    case "Enter": {
-      return "row";
+
+// src/components/Table/RowActionsMenu.tsx
+import { useSignals as _useSignals7 } from "@preact-signals/safe-react/tracking";
+import React7 from "react";
+import { DropdownMenu as DropdownMenu2, toLocalizedString, useTranslation as useTranslation2 } from "@dxos/react-ui";
+var RowActionsMenu = ({ model, modals }) => {
+  var _effect = _useSignals7();
+  try {
+    const { t } = useTranslation2(translationKey);
+    const hasSelection = model.selection.hasSelection.value;
+    const state = modals.state.value;
+    if (state?.type !== "row") {
+      return null;
     }
-    case "ArrowLeft":
-    case "ArrowRight":
-    case "Tab":
-      return "col";
-  }
-};
-var determineNavigationDelta = ({ key, shift }) => {
-  switch (key) {
-    case "ArrowUp":
-    case "ArrowLeft":
-      return -1;
-    case "ArrowDown":
-    case "ArrowRight":
-      return 1;
+    return /* @__PURE__ */ React7.createElement(DropdownMenu2.Root, {
+      modal: false,
+      open: true,
+      onOpenChange: modals.close
+    }, /* @__PURE__ */ React7.createElement(DropdownMenu2.VirtualTrigger, {
+      virtualRef: modals.trigger
+    }), /* @__PURE__ */ React7.createElement(DropdownMenu2.Content, null, /* @__PURE__ */ React7.createElement(DropdownMenu2.Viewport, null, model.features.dataEditable !== false && /* @__PURE__ */ React7.createElement(DropdownMenu2.Item, {
+      "data-testid": "row-menu-delete",
+      onClick: () => model.deleteRow(state.rowIndex)
+    }, t(hasSelection ? "bulk delete row label" : "delete row label")), model.rowActions?.map((action) => /* @__PURE__ */ React7.createElement(DropdownMenu2.Item, {
+      key: action.id,
+      "data-testid": `row-action-${action.id}`,
+      onClick: () => {
+        modals.close();
+        model.handleRowAction(action.id, state.rowIndex);
+      }
+    }, toLocalizedString(action.label, t)))), /* @__PURE__ */ React7.createElement(DropdownMenu2.Arrow, null)));
+  } finally {
+    _effect.f();
   }
-  return shift ? -1 : 1;
 };
 
 // src/components/Table/Table.tsx
-var __dxlog_file3 = "/__w/dxos/dxos/packages/ui/react-ui-table/src/components/Table/Table.tsx";
+var columnDefault = {
+  grid: {
+    minSize: 80,
+    maxSize: 640
+  }
+};
+var rowDefault = {
+  frozenRowsStart: {
+    readonly: true,
+    focusUnfurl: false
+  }
+};
 var TableRoot = ({ children, role = "article" }) => {
   var _effect = _useSignals8();
   try {
@@ -865,14 +898,19 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
   try {
     const [dxGrid, setDxGrid] = useState4(null);
     const { hasAttention } = useAttention(model?.id ?? "table");
-    const { t } = useTranslation3(translationKey);
     const modals = useMemo5(() => new ModalController(), []);
     const draftRowCount = model?.getDraftRowCount() ?? 0;
+    const handleSave = useCallback5(() => {
+      dxGrid?.updateCells(true);
+      dxGrid?.requestUpdate();
+    }, [
+      dxGrid
+    ]);
     const frozen = useMemo5(() => {
       const noActionColumn = model?.features.dataEditable === false && model?.features.schemaEditable === false && model.rowActions.length === 0;
       return {
         frozenRowsStart: 1,
-        frozenRowsEnd: draftRowCount,
+        frozenRowsEnd: Math.max(1, draftRowCount),
         frozenColsStart: model?.features.selection.enabled ? 1 : 0,
         frozenColsEnd: noActionColumn ? 0 : 1
       };
@@ -883,7 +921,7 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
     const getCells = useCallback5((range, plane) => presentation?.getCells(range, plane) ?? {}, [
       presentation
     ]);
-    useEffect4(() => {
+    useEffect3(() => {
       if (!presentation || !dxGrid) {
         return;
       }
@@ -893,6 +931,30 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
       dxGrid,
       getCells
     ]);
+    const handleInsertRowResult = useCallback5((insertResult) => {
+      if (insertResult === "draft") {
+        requestAnimationFrame(() => {
+          dxGrid?.setFocus({
+            plane: "frozenRowsEnd",
+            col: 0,
+            row: 0
+          });
+          dxGrid?.refocus();
+        });
+      } else {
+        requestAnimationFrame(() => {
+          dxGrid?.setFocus({
+            plane: "grid",
+            col: 0,
+            row: model ? model.getRowCount() - 1 : 0
+          });
+          dxGrid?.refocus();
+        });
+      }
+    }, [
+      model,
+      dxGrid
+    ]);
     useImperativeHandle(forwardedRef, () => {
       if (!presentation || !dxGrid) {
         return {};
@@ -905,18 +967,38 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
             dxGrid.updateCells(true);
             dxGrid.requestUpdate();
           }
-        }
+        },
+        handleInsertRowResult
       };
     }, [
       presentation,
+      dxGrid,
+      model
+    ]);
+    const handleSaveDraftRow = useCallback5((rowIndex = 0) => {
+      if (model && dxGrid) {
+        const didCommitSuccessfully = model.commitDraftRow(rowIndex);
+        if (didCommitSuccessfully) {
+          requestAnimationFrame(() => {
+            dxGrid.scrollToEndRow();
+          });
+        }
+      }
+    }, [
+      model,
       dxGrid
     ]);
     const handleGridClick = useCallback5((event) => {
-      const rowIndex = safeParseInt(event.target.closest("[aria-rowindex]")?.ariaRowIndex ?? "");
-      if (rowIndex != null) {
+      const cell = closestCell(event.target);
+      if (cell) {
+        const { row: rowIndex, plane } = cell;
         if (onRowClick) {
-          const row = model?.getRowAt(rowIndex);
-          row && onRowClick(row);
+          if (plane === "grid") {
+            const row = model?.getRowAt(rowIndex);
+            row && onRowClick(row);
+          } else {
+            onRowClick(cell);
+          }
         }
         if (model?.features.selection.enabled && model?.selection.selectionMode === "single") {
           model.selection.toggleSelectionForRowIndex(rowIndex);
@@ -952,14 +1034,7 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
             break;
           }
           case "saveDraftRow": {
-            if (model) {
-              const didCommitSuccessfully = model.commitDraftRow(data.rowIndex);
-              if (dxGrid && didCommitSuccessfully) {
-                requestAnimationFrame(() => {
-                  dxGrid.scrollToEndRow();
-                });
-              }
-            }
+            handleSaveDraftRow();
             break;
           }
         }
@@ -998,29 +1073,20 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
       modals,
       dxGrid
     ]);
-    const handleFocus = useCallback5((increment, delta) => {
-      if (dxGrid) {
-        dxGrid.refocus(increment, delta);
-      }
-    }, [
-      dxGrid
-    ]);
-    const handleEnter = useCallback5((cell) => {
-      if (!model?.features.dataEditable) {
-        return;
-      }
-      if (model && cell.row === model.getRowCount() - 1) {
-        model.insertRow();
-        if (dxGrid) {
-          requestAnimationFrame(() => {
-            dxGrid?.scrollToRow(cell.row + 1);
-            dxGrid?.refocus("row", 1);
-          });
+    const handleFocus = useCallback5((increment, delta, cell) => {
+      if (dxGrid && model) {
+        if (cell?.plane === "grid" && cell?.row >= model.getRowCount() - 1) {
+          handleInsertRowResult(draftRowCount < 1 ? model.insertRow() : "final");
+        } else if (cell?.plane === "frozenRowsEnd" && increment === "row") {
+          handleSaveDraftRow(cell.row);
+          handleInsertRowResult(model.insertRow());
+        } else {
+          dxGrid.refocus(increment, delta);
         }
       }
     }, [
-      model,
-      dxGrid
+      dxGrid,
+      model
     ]);
     const handleKeyDown = useCallback5((event) => {
       if (!model?.features.dataEditable) {
@@ -1030,15 +1096,63 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
       if (!model || !cell) {
         return;
       }
+      if (event.metaKey || event.ctrlKey) {
+        switch (event.key) {
+          case "c": {
+            try {
+              const cellData = model.getCellData(cell);
+              const textContent = cellData?.toString() ?? "";
+              void navigator.clipboard.writeText(textContent);
+              event.preventDefault();
+            } catch (error) {
+              console.warn("Failed to copy cell content:", error);
+            }
+            break;
+          }
+          case "v": {
+            event.preventDefault();
+            void navigator.clipboard.readText().then((clipboardText) => {
+              try {
+                model.setCellData(cell, clipboardText);
+                handleSave();
+              } catch {
+                const cellElement = event.target.closest('[data-dx-grid-action="cell"]');
+                if (cellElement) {
+                  const rect = cellElement.getBoundingClientRect();
+                  const editRequest = new DxEditRequest({
+                    cellIndex: `${cell.plane},${cell.col},${cell.row}`,
+                    cellBox: {
+                      insetInlineStart: rect.left,
+                      insetBlockStart: rect.top,
+                      inlineSize: rect.width,
+                      blockSize: rect.height
+                    },
+                    cellElement,
+                    initialContent: clipboardText
+                  });
+                  cellElement.dispatchEvent(editRequest);
+                }
+              }
+            });
+            break;
+          }
+        }
+      }
       switch (event.key) {
         case "Backspace":
         case "Delete": {
-          model.setCellData(cell, void 0);
+          try {
+            model.setCellData(cell, void 0);
+            event.preventDefault();
+          } catch {
+          }
           break;
         }
       }
     }, [
-      model
+      model,
+      dxGrid,
+      handleSave
     ]);
     const handleAxisResize = useCallback5((event) => {
       if (event.axis === "col") {
@@ -1065,59 +1179,6 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
       model,
       dxGrid
     ]);
-    const handleQuery = useCallback5(async ({ field, props }, text) => {
-      if (model && props.referenceSchema && field.referencePath) {
-        const space = getSpace2(model.view);
-        invariant3(space, void 0, {
-          F: __dxlog_file3,
-          L: 325,
-          S: void 0,
-          A: [
-            "space",
-            ""
-          ]
-        });
-        let schema2;
-        if (client) {
-          schema2 = client.graph.schemaRegistry.getSchema(props.referenceSchema);
-        }
-        if (!schema2) {
-          schema2 = space.db.schemaRegistry.getSchema(props.referenceSchema);
-        }
-        if (schema2) {
-          const { objects } = await space.db.query(Filter.type(schema2)).run();
-          const options = objects.map((obj) => {
-            const value = getValue(obj, field.referencePath);
-            if (!value || typeof value !== "string") {
-              return void 0;
-            }
-            return {
-              label: value,
-              data: obj
-            };
-          }).filter(isNotFalsy);
-          return [
-            ...options,
-            {
-              label: t("create new object label", {
-                text
-              }),
-              data: createOption(text)
-            }
-          ];
-        }
-      }
-      return [];
-    }, [
-      model,
-      client,
-      t
-    ]);
-    const handleSave = useCallback5(() => {
-      dxGrid?.updateCells(true);
-    }, [
-      dxGrid
-    ]);
     if (!model || !modals) {
       return /* @__PURE__ */ React8.createElement("span", {
         role: "none",
@@ -1130,20 +1191,21 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
       model,
       modals,
       schema,
-      onEnter: handleEnter,
       onFocus: handleFocus,
-      onQuery: handleQuery,
-      onSave: handleSave
+      onSave: handleSave,
+      client
     }), /* @__PURE__ */ React8.createElement(Grid.Content, {
       className: mx("[--dx-grid-base:var(--baseSurface)]", gridSeparatorInlineEnd, gridSeparatorBlockEnd),
       frozen,
       columns: model.columnMeta.value,
+      columnDefault,
+      rowDefault,
       limitRows: model.getRowCount() ?? 0,
       limitColumns: model.projection.fields.length,
       overscroll: "trap",
       onAxisResize: handleAxisResize,
       onClick: handleGridClick,
-      onKeyDown: handleKeyDown,
+      onKeyDownCapture: handleKeyDown,
       onWheelCapture: handleWheel,
       ref: setDxGrid
     }), /* @__PURE__ */ React8.createElement(RowActionsMenu, {
@@ -1171,7 +1233,7 @@ var Table = {
 
 // src/components/Table/DynamicTable.tsx
 import { useSignals as _useSignals9 } from "@preact-signals/safe-react/tracking";
-import React9, { useRef as useRef3, useMemo as useMemo6, useCallback as useCallback6 } from "react";
+import React9, { useCallback as useCallback6, useMemo as useMemo6, useRef as useRef3 } from "react";
 import { useDefaultValue } from "@dxos/react-ui";
 import { mx as mx2 } from "@dxos/react-ui-theme";
 var DynamicTable = ({ classNames, name = "example.com/dynamic-table", rows, properties, jsonSchema: _jsonSchema, schema, rowActions, onRowClick, onRowAction, ...props }) => {
@@ -1251,7 +1313,7 @@ import { useSignals as _useSignals10 } from "@preact-signals/safe-react/tracking
 import { Rx } from "@effect-rx/rx-react";
 import React10, { useMemo as useMemo7 } from "react";
 import { live as live2 } from "@dxos/live-object";
-import { createGapSeparator, createMenuAction, MenuProvider, ToolbarMenu, useMenuActions } from "@dxos/react-ui-menu";
+import { MenuProvider, ToolbarMenu, createGapSeparator, createMenuAction, useMenuActions } from "@dxos/react-ui-menu";
 import { rxFromSignal } from "@dxos/react-ui-menu";
 var createTableToolbarActions = ({ state, onAdd, onSave, customActions }) => Rx.make((get) => {
   const add = createMenuAction("add-row", onAdd, {
@@ -1338,7 +1400,6 @@ export {
   TablePresentation,
   TableToolbar,
   cellClassesForRowSelection,
-  createTable,
   getBaseSchema,
   makeDynamicTable,
   narrowSchema,