@dxos/react-ui-table 0.8.4-main.67995b8 → 0.8.4-main.72ec0f3

package/dist/lib/browser/index.mjs

@@ -7,7 +7,6 @@ import {
   TableModel,
   TablePresentation,
   cellClassesForRowSelection,
-  createTable,
   getBaseSchema,
   makeDynamicTable,
   narrowSchema,
@@ -16,8 +15,8 @@ import {
   touch,
   useAddRow,
   useTableModel
-} from "./chunk-5XLSHLOG.mjs";
-import "./chunk-L2LSB6KV.mjs";
+} from "./chunk-GS2UNGJK.mjs";
+import "./chunk-2PFAPQL4.mjs";
 
 // src/translations.ts
 var translationKey = "react-ui-table";
@@ -29,8 +28,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",
@@ -52,271 +51,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 { useSignals as _useSignals7 } from "@preact-signals/safe-react/tracking";
+import * as String2 from "effect/String";
+import React7, { forwardRef, useCallback as useCallback4, useEffect as useEffect3, useImperativeHandle, useMemo as useMemo4, 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 { FormatEnum, TypeEnum } from "@dxos/echo-schema";
+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 as FormatEnum2, TypeEnum } from "@dxos/echo/internal";
 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";
 
 // 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: {
@@ -335,71 +100,108 @@ 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 * as Schema from "effect/Schema";
+import React2, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Filter, Obj } from "@dxos/echo";
+import { FormatEnum, Ref, getValue } from "@dxos/echo/internal";
 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 { parseCellIndex, useGridContext as useGridContext2 } from "@dxos/react-ui-grid";
+import { getDeep, isTruthy, 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, onCreate, __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: 57,
+        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(isTruthy);
       }
-      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: 98,
+            S: void 0,
+            A: [
+              "draftRow",
+              ""
+            ]
+          });
+          return draftRow.data;
+        } else {
+          const row = model.getRowAt(cell.row);
+          invariant(row, void 0, {
+            F: __dxlog_file,
+            L: 102,
+            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
@@ -407,93 +209,128 @@ 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
+    ]);
+    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?.();
       }
       setLocalEditing(nextOpen);
     }, []);
+    const refSchema = useMemo(() => {
+      if (fieldProjection.props.format === FormatEnum.Ref && fieldProjection.props.referenceSchema) {
+        const { schema: refSchema2 } = getSchema({
+          typename: fieldProjection.props.referenceSchema
+        });
+        return refSchema2;
+      }
+      return null;
+    }, [
+      fieldProjection.props.format,
+      fieldProjection.props.referenceSchema,
+      getSchema
+    ]);
+    const createSchema = useMemo(() => {
+      return refSchema ? Schema.omit("id")(refSchema) : null;
+    }, [
+      refSchema
+    ]);
+    const handleCreate = useCallback((values) => {
+      if (refSchema && onCreate) {
+        const objectWithId = onCreate(refSchema, values);
+        if (objectWithId) {
+          const ref = Ref.make(objectWithId);
+          const path = fieldProjection.field.path;
+          setDeep(originalRow, [
+            path
+          ], ref);
+        }
+      }
+      contextEditing?.cellElement?.focus();
+      setEditing(null);
+      setLocalEditing(false);
+      onSave?.();
+    }, [
+      fieldProjection.field.path,
+      onSave,
+      contextEditing,
+      originalRow,
+      refSchema,
+      onCreate
+    ]);
     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,
+      ...createSchema && {
+        onCreate: handleCreate,
+        createSchema,
+        createInitialValuePath: fieldProjection.field.referencePath,
+        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, onCreate, 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;
       }
@@ -502,7 +339,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",
@@ -514,21 +351,22 @@ 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 === FormatEnum2.SingleSelect || fieldProjection?.props.format === FormatEnum2.Ref) {
+      return /* @__PURE__ */ React3.createElement(FormCellEditor, {
         fieldProjection,
         model,
         schema,
         __gridScope,
-        onSave
+        onSave,
+        onCreate,
+        client,
+        modals
       });
     }
-    return /* @__PURE__ */ React7.createElement(TableCellEditor, {
+    return /* @__PURE__ */ React3.createElement(TableCellEditor, {
       model,
       modals,
-      onEnter,
       onFocus,
-      onQuery,
       onSave,
       __gridScope
     });
@@ -537,19 +375,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;
       }
@@ -558,7 +395,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: 121,
         S: void 0,
         A: [
           "fieldProjection",
@@ -568,40 +405,9 @@ var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gri
       return fieldProjection2;
     }, [
       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
+      editing
     ]);
-    const handleEnter = useCallback4(async (value) => {
+    const handleEnter = useCallback2(async (value) => {
       if (!model || !editing) {
         return;
       }
@@ -610,33 +416,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;
       }
@@ -644,19 +456,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?.();
@@ -668,16 +481,15 @@ var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gri
       model,
       editing,
       onFocus,
-      onEnter,
       fieldProjection,
       setEditing,
       onSave
     ]);
-    const extension = useMemo4(() => {
+    const extensions = useMemo2(() => {
       if (!fieldProjection) {
         return [];
       }
-      const extension2 = [
+      const extensions2 = [
         editorKeys({
           onClose: handleClose,
           ...editing?.initialContent && {
@@ -685,114 +497,31 @@ var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gri
           }
         })
       ];
-      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);
-              }
+      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");
             }
-          }
-        }));
-      }
-      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;
-          }
-        }
+          });
+        }, 10)));
       }
-      return extension2;
+      return extensions2;
     }, [
       model,
       modals,
       editing,
       fieldProjection,
-      handleClose,
-      themeMode
+      handleClose
     ]);
-    const getCellContent = useCallback4(() => {
+    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) : "";
       }
@@ -800,12 +529,12 @@ var TableCellEditor = ({ model, modals, onEnter, onFocus, onQuery, onSave, __gri
       model,
       editing
     ]);
-    return /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement(CellValidationMessage, {
-      validationError: _validationError,
-      variant: _validationVariant,
+    return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(CellValidationMessage, {
+      validationError,
+      variant: validationVariant,
       __gridScope
-    }), /* @__PURE__ */ React7.createElement(GridCellEditor, {
-      extension,
+    }), /* @__PURE__ */ React3.createElement(GridCellEditor, {
+      extensions,
       getCellContent,
       onBlur: handleBlur,
       slots: editorSlots
@@ -839,12 +568,171 @@ var determineNavigationDelta = ({ key, shift }) => {
   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/RowActionsMenu.tsx
+import { useSignals as _useSignals6 } from "@preact-signals/safe-react/tracking";
+import React6 from "react";
+import { DropdownMenu as DropdownMenu2, toLocalizedString, useTranslation as useTranslation2 } from "@dxos/react-ui";
+var RowActionsMenu = ({ model, modals }) => {
+  var _effect = _useSignals6();
+  try {
+    const { t } = useTranslation2(translationKey);
+    const hasSelection = model.selection.hasSelection.value;
+    const state = modals.state.value;
+    if (state?.type !== "row") {
+      return null;
+    }
+    return /* @__PURE__ */ React6.createElement(DropdownMenu2.Root, {
+      modal: false,
+      open: true,
+      onOpenChange: modals.close
+    }, /* @__PURE__ */ React6.createElement(DropdownMenu2.VirtualTrigger, {
+      virtualRef: modals.trigger
+    }), /* @__PURE__ */ React6.createElement(DropdownMenu2.Content, null, /* @__PURE__ */ React6.createElement(DropdownMenu2.Viewport, null, model.rowActions?.length > 0 && /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(DropdownMenu2.Group, null, model.rowActions?.map((action) => /* @__PURE__ */ React6.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__ */ React6.createElement(DropdownMenu2.Separator, null)), model.features.dataEditable !== false && /* @__PURE__ */ React6.createElement(DropdownMenu2.Item, {
+      "data-testid": "row-menu-delete",
+      onClick: () => model.deleteRow(state.rowIndex)
+    }, t(hasSelection ? "bulk delete row label" : "delete row label"))), /* @__PURE__ */ React6.createElement(DropdownMenu2.Arrow, null)));
+  } finally {
+    _effect.f();
+  }
+};
+
 // 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();
+  var _effect = _useSignals7();
   try {
-    return /* @__PURE__ */ React8.createElement("div", {
+    return /* @__PURE__ */ React7.createElement("div", {
       role: "none",
       className: mx("relative !border-separator [&_.dx-grid]:max-is-[--dx-grid-content-inline-size] [&_.dx-grid]:max-bs-[--dx-grid-content-block-size]", role === "card--popover" && "popover-card-height", role === "section" && "attention-surface", role === "card--intrinsic" && "[&_.dx-grid]:bs-[--dx-grid-content-block-size]", [
         "card--popover",
@@ -859,19 +747,24 @@ var TableRoot = ({ children, role = "article" }) => {
     _effect.f();
   }
 };
-var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttention, schema, client, onRowClick }, forwardedRef) => {
-  var _effect = _useSignals8();
+var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttention, schema, client, onCreate, onRowClick, testId }, forwardedRef) => {
+  var _effect = _useSignals7();
   try {
     const [dxGrid, setDxGrid] = useState4(null);
     const { hasAttention } = useAttention(model?.id ?? "table");
-    const { t } = useTranslation3(translationKey);
-    const modals = useMemo5(() => new ModalController(), []);
+    const modals = useMemo4(() => new ModalController(), []);
     const draftRowCount = model?.getDraftRowCount() ?? 0;
-    const frozen = useMemo5(() => {
+    const handleSave = useCallback4(() => {
+      dxGrid?.updateCells(true);
+      dxGrid?.requestUpdate();
+    }, [
+      dxGrid
+    ]);
+    const frozen = useMemo4(() => {
       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
       };
@@ -879,10 +772,10 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
       model,
       draftRowCount
     ]);
-    const getCells = useCallback5((range, plane) => presentation?.getCells(range, plane) ?? {}, [
+    const getCells = useCallback4((range, plane) => presentation?.getCells(range, plane) ?? {}, [
       presentation
     ]);
-    useEffect4(() => {
+    useEffect3(() => {
       if (!presentation || !dxGrid) {
         return;
       }
@@ -892,6 +785,30 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
       dxGrid,
       getCells
     ]);
+    const handleInsertRowResult = useCallback4((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 {};
@@ -904,18 +821,38 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
             dxGrid.updateCells(true);
             dxGrid.requestUpdate();
           }
-        }
+        },
+        handleInsertRowResult
       };
     }, [
       presentation,
+      dxGrid,
+      model
+    ]);
+    const handleSaveDraftRow = useCallback4((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 handleGridClick = useCallback4((event) => {
+      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);
@@ -951,14 +888,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;
           }
         }
@@ -997,31 +927,22 @@ 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 = useCallback4((increment, delta, cell) => {
+      if (dxGrid && model) {
+        if (cell?.plane === "grid" && cell?.row >= model.getRowCount() - 1 && increment !== "col") {
+          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) => {
+    const handleKeyDown = useCallback4((event) => {
       if (!model?.features.dataEditable) {
         return;
       }
@@ -1029,21 +950,66 @@ 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, String2.trim(clipboardText).replace(/[\n\r]+/, " "));
+                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": {
           try {
             model.setCellData(cell, void 0);
             event.preventDefault();
+            handleSave();
           } catch {
           }
           break;
         }
       }
     }, [
-      model
+      model,
+      dxGrid,
+      handleSave
     ]);
-    const handleAxisResize = useCallback5((event) => {
+    const handleAxisResize = useCallback4((event) => {
       if (event.axis === "col") {
         const columnIndex = parseInt(event.index, 10);
         model?.setColumnWidth(columnIndex, event.size);
@@ -1051,7 +1017,7 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
     }, [
       model
     ]);
-    const handleWheel = useCallback5((event) => {
+    const handleWheel = useCallback4((event) => {
       if (!ignoreAttention && !hasAttention) {
         event.stopPropagation();
       }
@@ -1059,7 +1025,7 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
       hasAttention,
       ignoreAttention
     ]);
-    const handleNewColumn = useCallback5(() => {
+    const handleNewColumn = useCallback4(() => {
       const columns = model?.getColumnCount();
       if (dxGrid && columns) {
         dxGrid.scrollToColumn(columns - 1);
@@ -1068,79 +1034,28 @@ 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: 330,
-          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", {
+      return /* @__PURE__ */ React7.createElement("span", {
         role: "none",
         className: "attention-surface"
       });
     }
-    return /* @__PURE__ */ React8.createElement(Grid.Root, {
+    return /* @__PURE__ */ React7.createElement(Grid.Root, {
       id: model.id ?? "table-grid"
-    }, /* @__PURE__ */ React8.createElement(TableValueEditor, {
+    }, /* @__PURE__ */ React7.createElement(TableValueEditor, {
       model,
       modals,
       schema,
-      onEnter: handleEnter,
       onFocus: handleFocus,
-      onQuery: handleQuery,
-      onSave: handleSave
-    }), /* @__PURE__ */ React8.createElement(Grid.Content, {
+      onSave: handleSave,
+      onCreate,
+      client
+    }), /* @__PURE__ */ React7.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",
@@ -1148,20 +1063,20 @@ var TableMain = /* @__PURE__ */ forwardRef(({ model, presentation, ignoreAttenti
       onClick: handleGridClick,
       onKeyDownCapture: handleKeyDown,
       onWheelCapture: handleWheel,
+      ...testId && {
+        "data-testid": testId
+      },
       ref: setDxGrid
-    }), /* @__PURE__ */ React8.createElement(RowActionsMenu, {
+    }), /* @__PURE__ */ React7.createElement(RowActionsMenu, {
       model,
       modals
-    }), /* @__PURE__ */ React8.createElement(ColumnActionsMenu, {
+    }), /* @__PURE__ */ React7.createElement(ColumnActionsMenu, {
       model,
       modals
-    }), /* @__PURE__ */ React8.createElement(ColumnSettings, {
+    }), /* @__PURE__ */ React7.createElement(ColumnSettings, {
       model,
       modals,
       onNewColumn: handleNewColumn
-    }), /* @__PURE__ */ React8.createElement(CreateRefPanel, {
-      model,
-      modals
     }));
   } finally {
     _effect.f();
@@ -1173,14 +1088,14 @@ 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 { useSignals as _useSignals8 } from "@preact-signals/safe-react/tracking";
+import React8, { useCallback as useCallback5, useMemo as useMemo5, 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 }) => {
-  var _effect = _useSignals9();
+  var _effect = _useSignals8();
   try {
-    const { typename, jsonSchema } = useMemo6(() => getBaseSchema({
+    const { jsonSchema } = useMemo5(() => getBaseSchema({
       typename: name,
       properties,
       jsonSchema: _jsonSchema,
@@ -1191,20 +1106,18 @@ var DynamicTable = ({ classNames, name = "example.com/dynamic-table", rows, prop
       _jsonSchema,
       schema
     ]);
-    const { projection, view } = useMemo6(() => makeDynamicTable({
-      typename,
+    const { projection, view } = useMemo5(() => makeDynamicTable({
       jsonSchema,
       properties
     }), [
-      typename,
       jsonSchema,
       properties
     ]);
     const tableRef = useRef3(null);
-    const handleCellUpdate = useCallback6((cell) => {
+    const handleCellUpdate = useCallback5((cell) => {
       tableRef.current?.update?.(cell);
     }, []);
-    const handleRowOrderChange = useCallback6(() => {
+    const handleRowOrderChange = useCallback5(() => {
       tableRef.current?.update?.();
     }, []);
     const features = useDefaultValue(props.features, () => ({
@@ -1224,20 +1137,20 @@ var DynamicTable = ({ classNames, name = "example.com/dynamic-table", rows, prop
       onRowOrderChange: handleRowOrderChange,
       onRowAction
     });
-    const presentation = useMemo6(() => {
+    const presentation = useMemo5(() => {
       if (model) {
         return new TablePresentation(model);
       }
     }, [
       model
     ]);
-    return /* @__PURE__ */ React9.createElement("div", {
+    return /* @__PURE__ */ React8.createElement("div", {
       role: "none",
       className: mx2("is-full bs-full grow grid", classNames)
-    }, /* @__PURE__ */ React9.createElement("div", {
+    }, /* @__PURE__ */ React8.createElement("div", {
       role: "none",
       className: "grid min-bs-0 overflow-hidden"
-    }, /* @__PURE__ */ React9.createElement(Table.Root, null, /* @__PURE__ */ React9.createElement(Table.Main, {
+    }, /* @__PURE__ */ React8.createElement(Table.Root, null, /* @__PURE__ */ React8.createElement(Table.Main, {
       ref: tableRef,
       model,
       presentation,
@@ -1250,43 +1163,46 @@ var DynamicTable = ({ classNames, name = "example.com/dynamic-table", rows, prop
 };
 
 // src/components/TableToolbar/TableToolbar.tsx
-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 { rxFromSignal } from "@dxos/react-ui-menu";
-var createTableToolbarActions = ({ state, onAdd, onSave, customActions }) => Rx.make((get) => {
-  const add = createMenuAction("add-row", onAdd, {
-    type: "add-row",
-    icon: "ph--plus--regular",
-    label: [
-      "add row",
-      {
-        ns: translationKey
-      }
-    ],
-    testId: "table.toolbar.add-row"
-  });
-  const save = createMenuAction("save-view", onSave, {
-    type: "save-view",
-    icon: "ph--floppy-disk--regular",
-    label: [
-      "save view label",
-      {
-        ns: translationKey
-      }
-    ],
-    testId: "table.toolbar.save-view",
-    iconOnly: false,
-    hidden: get(rxFromSignal(() => !state.viewDirty))
-  });
+import { useSignals as _useSignals9 } from "@preact-signals/safe-react/tracking";
+import { Atom } from "@effect-atom/atom-react";
+import React9, { useMemo as useMemo6 } from "react";
+import { live } from "@dxos/live-object";
+import { MenuProvider, ToolbarMenu, createGapSeparator, createMenuAction, useMenuActions } from "@dxos/react-ui-menu";
+import { atomFromSignal } from "@dxos/react-ui-menu";
+var createTableToolbarActions = ({ state, onAdd, onSave, customActions }) => Atom.make((get) => {
+  const nodes = [];
+  if (onAdd) {
+    const add = createMenuAction("add-row", onAdd, {
+      type: "add-row",
+      icon: "ph--plus--regular",
+      label: [
+        "add row",
+        {
+          ns: translationKey
+        }
+      ],
+      testId: "table.toolbar.add-row"
+    });
+    nodes.push(add);
+  }
+  if (onSave) {
+    const save = createMenuAction("save-view", onSave, {
+      type: "save-view",
+      icon: "ph--floppy-disk--regular",
+      label: [
+        "save view label",
+        {
+          ns: translationKey
+        }
+      ],
+      testId: "table.toolbar.save-view",
+      iconOnly: false,
+      hidden: get(atomFromSignal(() => !state.viewDirty))
+    });
+    nodes.push(save);
+  }
   const gap = createGapSeparator();
-  const nodes = [
-    add,
-    save,
-    ...gap.nodes
-  ];
+  nodes.push(...gap.nodes);
   const edges = nodes.map(({ id: target }) => ({
     source: "root",
     target
@@ -1302,12 +1218,12 @@ var createTableToolbarActions = ({ state, onAdd, onSave, customActions }) => Rx.
   };
 });
 var TableToolbar = ({ classNames, viewDirty, attendableId, onAdd, onSave, customActions }) => {
-  var _effect = _useSignals10();
+  var _effect = _useSignals9();
   try {
-    const state = useMemo7(() => live2({
+    const state = useMemo6(() => live({
       viewDirty
     }), []);
-    const actionsCreator = useMemo7(() => createTableToolbarActions({
+    const actionsCreator = useMemo6(() => createTableToolbarActions({
       state,
       onAdd,
       onSave,
@@ -1319,10 +1235,10 @@ var TableToolbar = ({ classNames, viewDirty, attendableId, onAdd, onSave, custom
       customActions
     ]);
     const menu = useMenuActions(actionsCreator);
-    return /* @__PURE__ */ React10.createElement(MenuProvider, {
+    return /* @__PURE__ */ React9.createElement(MenuProvider, {
       ...menu,
       attendableId
-    }, /* @__PURE__ */ React10.createElement(ToolbarMenu, {
+    }, /* @__PURE__ */ React9.createElement(ToolbarMenu, {
       classNames
     }));
   } finally {
@@ -1341,7 +1257,6 @@ export {
   TablePresentation,
   TableToolbar,
   cellClassesForRowSelection,
-  createTable,
   getBaseSchema,
   makeDynamicTable,
   narrowSchema,