@dxos/react-ui-table 0.8.4-main.422d1c7879 → 0.8.4-main.43cb759274

package/src/components/TableCellEditor/TableCellEditor.stories.tsx

@@ -5,8 +5,7 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React from 'react';
 
-import { Obj } from '@dxos/echo';
-import { View } from '@dxos/echo';
+import { Obj, Type, View } from '@dxos/echo';
 import { random } from '@dxos/random';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { Grid, type GridEditing, defaultRowSize } from '@dxos/react-ui-grid';
@@ -14,8 +13,9 @@ import { withLayout, withTheme } from '@dxos/react-ui/testing';
 import { ViewModel } from '@dxos/schema';
 import { Task } from '@dxos/types';
 
+import { translations } from '#translations';
+
 import { useTestTableModel } from '../../testing';
-import { translations } from '../../translations';
 import { Table } from '../../types';
 import { TableCellEditor } from './TableCellEditor';
 
@@ -52,7 +52,10 @@ const meta = {
       createIdentity: true,
       createSpace: true,
       onCreateSpace: async ({ space }) => {
-        const { view, jsonSchema } = await ViewModel.makeFromDatabase({ db: space.db, typename: Task.Task.typename });
+        const { view, jsonSchema } = await ViewModel.makeFromDatabase({
+          db: space.db,
+          typename: Type.getTypename(Task.Task),
+        });
         const table = Table.make({ view, jsonSchema });
         space.db.add(table);
         Array.from({ length: 10 }).forEach(() => {

package/src/components/testing.ts

@@ -6,7 +6,7 @@ import { Atom } from '@effect-atom/atom-react';
 import * as Schema from 'effect/Schema';
 import { useEffect } from 'react';
 
-import { Format, Type } from '@dxos/echo';
+import { DXN, Format, Type } from '@dxos/echo';
 import { TypeEnum } from '@dxos/echo/internal';
 import { setValue } from '@dxos/effect';
 import { random } from '@dxos/random';
@@ -17,12 +17,7 @@ export const TestSchema = Schema.Struct({
   age: Schema.optional(Schema.Number),
   active: Schema.optional(Schema.Boolean),
   netWorth: Schema.optional(Schema.Number),
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.test',
-    version: '0.1.0',
-  }),
-);
+}).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
 
 export type TestItem = {
   name: string;

package/src/hooks/useProjectionModel.ts

@@ -5,7 +5,7 @@
 import { type Registry } from '@effect-atom/atom-react';
 import { useState } from 'react';
 
-import { JsonSchema, Type } from '@dxos/echo';
+import { Type } from '@dxos/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 import { ProjectionModel, createEchoChangeCallback } from '@dxos/schema';
 
@@ -21,13 +21,12 @@ export const useProjectionModel = <S extends Type.AnyEntity>(
   useAsyncEffect(async () => {
     if (schema && table) {
       const view = await table.view.load();
-      // For mutable schemas (EchoSchema), use the live jsonSchema reference for reactivity.
-      // For immutable schemas, create a snapshot.
-      const jsonSchema = Type.isMutable(schema) ? schema.jsonSchema : JsonSchema.toJsonSchema(schema);
+      // Use the live jsonSchema reference for reactivity.
+      const jsonSchema = schema.jsonSchema;
 
       // Always use createEchoChangeCallback since the view is ECHO-backed.
-      // Pass schema only when mutable to allow schema mutations.
-      const change = createEchoChangeCallback(view, Type.isMutable(schema) ? schema : undefined);
+      // Pass the type entity only when stored, to allow schema mutations.
+      const change = createEchoChangeCallback(view, Type.getDatabase(schema) != null ? schema : undefined);
 
       const projection = new ProjectionModel({ registry, view, baseSchema: jsonSchema, change });
       projection.normalizeView();

package/src/hooks/useTableModel.ts

@@ -44,7 +44,7 @@ export const useTableModel = <T extends TableRow = TableRow>({
   ...props
 }: UseTableModelProps<T>): TableModel<T> | undefined => {
   const registry = useContext(RegistryContext);
-  const selected = useSelected(object && Obj.getDXN(object).toString(), 'multi');
+  const selected = useSelected(object && Obj.getURI(object), 'multi');
   const initialSelection = useMemo(() => selected, [object]);
 
   const [model, setModel] = useState<TableModel<T>>();

package/src/index.ts

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

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

@@ -6,7 +6,7 @@ import { Registry } from '@effect-atom/atom-react';
 import * as Schema from 'effect/Schema';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Filter, JsonSchema, Query, Type } from '@dxos/echo';
+import { DXN, Filter, JsonSchema, Query, Type } from '@dxos/echo';
 import { createEchoSchema } from '@dxos/echo/testing';
 import { ProjectionModel, ViewModel, createDirectChangeCallback } from '@dxos/schema';
 
@@ -118,15 +118,10 @@ describe('TableModel', () => {
 const Test = Schema.Struct({
   title: Schema.String,
   completed: Schema.Boolean,
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.test',
-    version: '0.1.0',
-  }),
-);
+}).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
 
 const createTableModel = (registry: Registry.Registry, props: Partial<TableModelProps> = {}): TableModel => {
-  const schema = createEchoSchema(Test);
+  const schema = createEchoSchema(Type.getSchema(Test));
   const view = ViewModel.make({
     query: Query.select(Filter.type(schema)),
     jsonSchema: schema.jsonSchema,
@@ -136,7 +131,7 @@ const createTableModel = (registry: Registry.Registry, props: Partial<TableModel
     registry,
     view,
     baseSchema: schema.jsonSchema,
-    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(schema)),
+    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(Type.getSchema(schema))),
   });
   projection.normalizeView();
   return new TableModel({

package/src/model/table-model.ts

@@ -5,13 +5,12 @@
 import { Atom, type Registry } from '@effect-atom/atom-react';
 
 import { Resource } from '@dxos/context';
-import { type Database, Format, Obj, Order, Query, type QueryAST, Ref } from '@dxos/echo';
-import { type View } from '@dxos/echo';
+import { type Database, Format, Obj, Order, Query, type QueryAST, Ref, Type, type View } from '@dxos/echo';
 import { type JsonProp, type JsonSchemaType, type Mutable, toEffectSchema } from '@dxos/echo/internal';
 import { getSnapshot } from '@dxos/echo/internal';
 import { getValue, setValue } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
-import { ObjectId } from '@dxos/keys';
+import { EntityId } from '@dxos/keys';
 import { type Label } from '@dxos/react-ui';
 import { formatForEditing, parseValue } from '@dxos/react-ui-form';
 import {
@@ -38,7 +37,7 @@ export type FieldSortType = {
 import { type SelectionMode, SelectionModel } from './selection-model';
 
 /**
- * Callback type for wrapping mutations in Obj.change().
+ * Callback type for wrapping mutations in Obj.update().
  * Contains separate callbacks for table object and row mutations.
  */
 export type TableChangeCallback<T extends TableRow> = {
@@ -53,10 +52,10 @@ export type TableChangeCallback<T extends TableRow> = {
  * Use this when the table and rows are stored in the ECHO database.
  */
 export const createEchoChangeCallback = <T extends TableRow>(table: Table.Table): TableChangeCallback<T> => ({
-  table: (mutate) => Obj.change(table, (table) => mutate(table as unknown as Table.Table)),
+  table: (mutate) => Obj.update(table, (table) => mutate(table as unknown as Table.Table)),
   row: (row, mutate) => {
     if (Obj.isObject(row)) {
-      Obj.change(row, (row) => mutate(row as T));
+      Obj.update(row, (row) => mutate(row as T));
     } else {
       mutate(row);
     }
@@ -112,7 +111,7 @@ export type TableModelProps<T extends TableRow = TableRow> = {
   projection: ProjectionModel;
   db?: Database.Database;
   /**
-   * Callbacks to wrap mutations in Obj.change().
+   * Callbacks to wrap mutations in Obj.update().
    * Use createEchoChangeCallback() for ECHO-backed objects or createDirectChangeCallback() for plain objects.
    */
   change?: TableChangeCallback<T>;
@@ -300,7 +299,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
   }
 
   public get id(): string {
-    return Obj.getDXN(this._object).toString();
+    return Obj.getURI(this._object);
   }
 
   public get view(): View.View {
@@ -524,7 +523,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
     }
 
     // NOTE(ZaymonFC): This is initialized with id because it's required in all schemata?
-    const draftData = { id: ObjectId.random() } as any as T;
+    const draftData = { id: EntityId.random() } as any as T;
     const validationErrors = this.validateDraftRowData(draftData);
 
     const draftRow: DraftRow<T> = {
@@ -695,8 +694,9 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
       const snapshot = { ...getSnapshot(currentRow) };
       setValue(snapshot, field.path, transformedValue);
 
-      const schema = Obj.getSchema(currentRow as unknown as Obj.Unknown);
-      invariant(schema);
+      const type = Obj.getType(currentRow as unknown as Obj.Unknown);
+      invariant(type);
+      const schema = Type.getSchema(type);
 
       const validationResult = validateSchema(schema, snapshot);
       if (validationResult && validationResult.length > 0) {
@@ -894,13 +894,13 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
       if (field) {
         // Persist sort to view.query.ast
         const newQuery = baseQuery.orderBy(Order.property<any>(field.path as string, inMemorySort.direction));
-        Obj.change(view, (view) => {
+        Obj.update(view, (view) => {
           view.query.ast = newQuery.ast as Mutable<typeof newQuery.ast>;
         });
       }
     } else {
       // Clear sort from view.query.ast
-      Obj.change(view, (view) => {
+      Obj.update(view, (view) => {
         view.query.ast = baseQuery.ast as Mutable<typeof baseQuery.ast>;
       });
     }

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

@@ -6,7 +6,7 @@ import { Registry } from '@effect-atom/atom-react';
 import * as Schema from 'effect/Schema';
 import { beforeEach, describe, expect, it } from 'vitest';
 
-import { Filter, JsonSchema, Query, Type } from '@dxos/echo';
+import { DXN, Filter, JsonSchema, Query, Type } from '@dxos/echo';
 import { createEchoSchema } from '@dxos/echo/testing';
 import { ProjectionModel, ViewModel, createDirectChangeCallback } from '@dxos/schema';
 
@@ -89,15 +89,10 @@ describe('TablePresentation', () => {
 const Test = Schema.Struct({
   title: Schema.String,
   count: Schema.Number,
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.test',
-    version: '0.1.0',
-  }),
-);
+}).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
 
 const createTableModel = (registry: Registry.Registry, props: Partial<TableModelProps> = {}): TableModel => {
-  const schema = createEchoSchema(Test);
+  const schema = createEchoSchema(Type.getSchema(Test));
   const view = ViewModel.make({
     query: Query.select(Filter.type(schema)),
     jsonSchema: schema.jsonSchema,
@@ -107,7 +102,7 @@ const createTableModel = (registry: Registry.Registry, props: Partial<TableModel
     registry,
     view,
     baseSchema: schema.jsonSchema,
-    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(schema)),
+    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(Type.getSchema(schema))),
   });
   projection.normalizeView();
   return new TableModel({ registry, object, projection, ...props });

package/src/model/table-presentation.ts

@@ -5,8 +5,7 @@
 import { Atom, type Registry } from '@effect-atom/atom-react';
 import * as Predicate from 'effect/Predicate';
 
-import { Obj } from '@dxos/echo';
-import { type View } from '@dxos/echo';
+import { Obj, type View } from '@dxos/echo';
 import { Format, TypeEnum, getValue } from '@dxos/echo/internal';
 import { cellClassesForFieldType, formatForDisplay } from '@dxos/react-ui-form';
 import {
@@ -209,8 +208,8 @@ export class TablePresentation<T extends TableRow = TableRow> {
     if (props.format === Format.TypeFormat.Ref && props.referenceSchema) {
       const targetObj = getValue(obj, field.path)?.target;
       if (targetObj) {
-        const dxn = Obj.getDXN(targetObj)?.toString();
-        cell.accessoryHtml = `<div role="none" class="absolute end-0 inset-y-0 p-(--dx-grid-cell-content-padding-block)"><dx-anchor dxn=${dxn} class="dx-button w-6 aspect-square min-h-0" data-dx-grid-action="accessory"><dx-icon icon="ph--link-simple--regular"/></dx-anchor></div>`;
+        const uri = Obj.getURI(targetObj);
+        cell.accessoryHtml = `<div role="none" class="absolute end-0 inset-y-0 p-(--dx-grid-cell-content-padding-block)"><dx-anchor uri=${uri} class="dx-button w-6 aspect-square min-h-0" data-dx-grid-action="accessory"><dx-icon icon="ph--link-simple--regular"/></dx-anchor></div>`;
       }
     }
 
@@ -473,8 +472,8 @@ export const cellClassesForRowSelection = (selected: boolean, selectionMode: Sel
 
   switch (selectionMode) {
     case 'single':
-      return ['dx-grid__cell--no-focus-unfurl !bg-current-surface hover:bg-hover-surface cursor-pointer!'];
+      return ['dx-grid__cell--no-focus-unfurl bg-current-surface! hover:bg-hover-surface cursor-pointer!'];
     case 'multiple':
-      return ['!bg-grid-cell-selected'];
+      return ['bg-grid-cell-selected!'];
   }
 };

package/src/testing/useTestTableModel.ts

@@ -5,10 +5,9 @@
 import { RegistryContext } from '@effect-atom/atom-react';
 import { type RefObject, useCallback, useContext, useMemo, useRef } from 'react';
 
-import { type Database, type Type } from '@dxos/echo';
-import { isMutable } from '@dxos/echo/internal';
+import { type Database, Filter, Type } from '@dxos/echo';
 import { random } from '@dxos/random';
-import { Filter, useQuery, useSchema } from '@dxos/react-client/echo';
+import { useQuery, useType } from '@dxos/react-client/echo';
 import { useClientStory } from '@dxos/react-client/testing';
 import { useGlobalFilteredObjects } from '@dxos/react-ui-search';
 import { type ProjectionModel, getTypenameFromQuery } from '@dxos/schema';
@@ -46,14 +45,14 @@ export const useTestTableModel = <T extends Type.AnyObj = Type.AnyObj>(): TestTa
   const tables = useQuery(space?.db, Filter.type(Table.Table));
   const table = tables.at(0);
   const typename = table?.view.target?.query ? getTypenameFromQuery(table.view.target.query.ast) : undefined;
-  const schema = useSchema<T>(space?.db, typename);
+  const schema = useType<T>(space?.db, typename);
   const projection = useProjectionModel(schema, table, registry);
 
   const features = useMemo(
     () => ({
       selection: { enabled: true, mode: 'multiple' as const },
       dataEditable: true,
-      schemaEditable: schema && isMutable(schema),
+      schemaEditable: schema != null && Type.getDatabase(schema) != null,
     }),
     [schema],
   );

package/src/types/Table.ts

@@ -6,12 +6,15 @@ import * as Match from 'effect/Match';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { Annotation, JsonSchema, Obj, Ref, Type } from '@dxos/echo';
-import { View } from '@dxos/echo';
+// QueryAST is referenced indirectly through `Type.InstanceType<typeof TableSchema>`
+// (Ref.Ref(View.View) → View.View → QueryAST.Query) in the emitted .d.ts; the
+// namespace import keeps the inferred types portable.
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { DXN, Annotation, JsonSchema, Obj, QueryAST, Ref, Type, View } from '@dxos/echo';
 import { FormInputAnnotation, type JsonPath, type JsonSchemaType, LabelAnnotation } from '@dxos/echo/internal';
 import { ViewAnnotation } from '@dxos/schema';
 
-export const Table = Schema.Struct({
+const TableSchema = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
 
   view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),
@@ -22,19 +25,15 @@ export const Table = Schema.Struct({
     value: Schema.Number,
   }).pipe(Schema.mutable, FormInputAnnotation.set(false)),
 }).pipe(
-  Type.object({
-    typename: 'org.dxos.type.table',
-    version: '0.1.0',
-  }),
   LabelAnnotation.set(['name']),
-  ViewAnnotation.set(true),
-  Annotation.IconAnnotation.set({
-    icon: 'ph--table--regular',
-    hue: 'green',
-  }),
+  ViewAnnotation.set(['view']),
+  Annotation.IconAnnotation.set({ icon: 'ph--table--regular', hue: 'green' }),
+  Type.makeObject(DXN.make('org.dxos.type.table', '0.1.0')),
 );
 
-export interface Table extends Schema.Schema.Type<typeof Table> {}
+// TODO(wittjosiah): Try to clean up this type inference.
+export interface Table extends Type.InstanceType<typeof TableSchema> {}
+export const Table = TableSchema;
 
 type MakeProps = {
   name?: string;

package/src/util/dynamic-table.test.ts

@@ -11,13 +11,14 @@ import { type TablePropertyDefinition, getBaseSchema, makeDynamicTable } from '.
 
 describe('makeDynamicTable', () => {
   /**
-   * Base case: plain jsonSchema (not from Echo / JsonSchema.toJsonSchema). Does not exercise the path
-   * where projection or schema are reactive, so this does not reproduce the Obj.change regression.
-   * Confirms makeDynamicTable + setProperties (title) works with plain objects.
+   * Builds the Type entity from a JSON schema, then makes the table.
+   * Confirms makeDynamicTable + setProperties (title) works for the jsonSchema path.
    */
-  test('makeDynamicTable with plain jsonSchema and properties with title does not throw', () => {
+  test('makeDynamicTable from a jsonSchema with properties with title does not throw', () => {
     const registry = Registry.make();
     const jsonSchema = {
+      typename: 'com.example.type.dynamicTablePlain',
+      version: '0.1.0',
       type: 'object' as const,
       properties: {
         id: { type: 'string' as const },
@@ -31,11 +32,8 @@ describe('makeDynamicTable', () => {
     ];
 
     expect(() => {
-      const { projection, object } = makeDynamicTable({
-        registry,
-        jsonSchema,
-        properties,
-      });
+      const { type } = getBaseSchema({ jsonSchema });
+      const { projection, object } = makeDynamicTable({ registry, type, properties });
       expect(projection).toBeDefined();
       expect(object).toBeDefined();
       expect(projection.getFields().length).toBeGreaterThan(0);
@@ -43,25 +41,20 @@ describe('makeDynamicTable', () => {
   });
 
   /**
-   * Regression test for the path where jsonSchema comes from getBaseSchema(typename, properties).
-   * That path uses Echo (ViewModel.make, JsonSchema.toJsonSchema); mutations must run inside Obj.change and on a
-   * cloned schema. This test ensures that flow does not throw.
+   * Builds the Type entity from property definitions, then makes the table.
+   * Confirms makeDynamicTable + setProperties (title) works for the property-definitions path.
    */
-  test('makeDynamicTable with jsonSchema from getBaseSchema(typename, properties) and properties with title does not throw', () => {
+  test('makeDynamicTable from getBaseSchema(typename, properties) with properties with title does not throw', () => {
     const registry = Registry.make();
     const typename = 'com.example.type.dynamicTableTest';
     const properties: TablePropertyDefinition[] = [
       { name: 'id', format: Format.TypeFormat.String },
       { name: 'name', format: Format.TypeFormat.String, title: 'Name' },
     ];
-    const { jsonSchema } = getBaseSchema({ typename, properties });
 
     expect(() => {
-      const { projection, object } = makeDynamicTable({
-        registry,
-        jsonSchema,
-        properties,
-      });
+      const { type } = getBaseSchema({ typename, properties });
+      const { projection, object } = makeDynamicTable({ registry, type, properties });
       expect(projection).toBeDefined();
       expect(object).toBeDefined();
       expect(projection.getFields().length).toBeGreaterThan(0);

package/src/util/dynamic-table.ts

@@ -5,13 +5,13 @@
 import { type Registry } from '@effect-atom/atom-react';
 import type * as Types from 'effect/Types';
 
-import { Filter, JsonSchema, Obj, Order, Query, type QueryAST, Ref, Type } from '@dxos/echo';
-import { type View } from '@dxos/echo';
+import { Filter, type JsonSchema, Obj, Order, Query, type QueryAST, Ref, Type, type View } from '@dxos/echo';
 import {
   ProjectionModel,
   type SchemaPropertyDefinition,
   ViewModel,
   createEchoChangeCallback,
+  getSchemaFromJsonSchema,
   getSchemaFromPropertyDefinitions,
 } from '@dxos/schema';
 
@@ -31,40 +31,41 @@ export type TablePropertyDefinition = SchemaPropertyDefinition & Partial<Propert
  */
 // TODO(burdon): Remove variance.
 export const getBaseSchema = ({
-  schema,
+  type,
   typename,
   properties,
   jsonSchema,
 }: {
-  schema?: Type.AnyEntity;
+  type?: Type.AnyEntity;
   typename?: string;
   properties?: TablePropertyDefinition[];
   jsonSchema?: Types.DeepMutable<JsonSchema.JsonSchema>;
-}): { typename: string; jsonSchema: Types.DeepMutable<JsonSchema.JsonSchema> } => {
-  if (typename && properties) {
-    const schema = getSchemaFromPropertyDefinitions(typename, properties);
-    return { typename: schema.typename, jsonSchema: JsonSchema.toJsonSchema(schema) };
-  } else if (schema) {
-    return { typename: Type.getTypename(schema)!, jsonSchema: JsonSchema.toJsonSchema(schema) };
-  } else if (typename && jsonSchema) {
-    return { typename, jsonSchema };
-  } else {
+}): { typename: string; type: Type.AnyEntity } => {
+  const resolved =
+    typename && properties
+      ? getSchemaFromPropertyDefinitions(typename, properties)
+      : (type ?? (jsonSchema ? getSchemaFromJsonSchema(jsonSchema, typename) : undefined));
+  if (!resolved) {
     throw new Error('invalid properties');
   }
+
+  return { typename: Type.getTypename(resolved)!, type: resolved };
 };
 
 export const makeDynamicTable = ({
   registry,
-  jsonSchema,
+  type,
   properties,
 }: {
   registry: Registry.Registry;
-  jsonSchema: Types.DeepMutable<JsonSchema.JsonSchema>;
+  type: Type.AnyEntity;
   properties?: TablePropertyDefinition[];
 }): { projection: ProjectionModel; object: Table.Table } => {
+  const jsonSchema = type.jsonSchema;
   const view = ViewModel.make({
     query: Query.select(Filter.everything()),
     jsonSchema,
+    type,
     ...(properties && { fields: properties.map((property) => property.name) }),
   });
   const object = Obj.make(Table.Table, { view: Ref.make(view), sizes: {} });
@@ -73,7 +74,7 @@ export const makeDynamicTable = ({
     registry,
     view,
     baseSchema: jsonSchema,
-    change: createEchoChangeCallback(view, jsonSchema),
+    change: createEchoChangeCallback(view, type),
   });
   projection.normalizeView();
   if (properties && projection.getFields()) {
@@ -93,7 +94,7 @@ const setProperties = (
     const field = projection.getFields().find((field) => field.path === property.name);
     if (field) {
       if (property.size !== undefined) {
-        Obj.change(table, (table) => {
+        Obj.update(table, (table) => {
           table.sizes[field.path] = property.size!;
         });
       }
@@ -111,7 +112,7 @@ const setProperties = (
         const currentQuery = Query.fromAst(Obj.getSnapshot(view).query.ast);
         // Use any type parameter since we're working with dynamic field paths
         const newQuery = currentQuery.orderBy(Order.property<any>(field.path as string, property.sort));
-        Obj.change(view, (view) => {
+        Obj.update(view, (view) => {
           // Type assertion needed because Query AST types have some variance issues.
           view.query.ast = newQuery.ast as typeof view.query.ast;
         });

package/dist/lib/browser/chunk-BF54SSNL.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types/Table.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { Annotation, JsonSchema, Obj, Ref, Type } from '@dxos/echo';\nimport { View } from '@dxos/echo';\nimport { FormInputAnnotation, type JsonPath, type JsonSchemaType, LabelAnnotation } from '@dxos/echo/internal';\nimport { ViewAnnotation } from '@dxos/schema';\n\nexport const Table = Schema.Struct({\n  name: Schema.String.pipe(Schema.optional),\n\n  view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),\n\n  sizes: Schema.Record({\n    // TODO(wittjosiah): Should be JsonPath.\n    key: Schema.String,\n    value: Schema.Number,\n  }).pipe(Schema.mutable, FormInputAnnotation.set(false)),\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.table',\n    version: '0.1.0',\n  }),\n  LabelAnnotation.set(['name']),\n  ViewAnnotation.set(true),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--table--regular',\n    hue: 'green',\n  }),\n);\n\nexport interface Table extends Schema.Schema.Type<typeof Table> {}\n\ntype MakeProps = {\n  name?: string;\n  sizes?: Record<string, number>;\n  view: View.View;\n  /** Required to auto-size columns. */\n  jsonSchema?: JsonSchemaType;\n};\n\n/**\n * Make a table as a view of a data set.\n */\nexport const make = ({ name, sizes = {}, view, jsonSchema }: MakeProps): Table => {\n  const table = Obj.make(Table, { name, view: Ref.make(view), sizes } as Obj.MakeProps<typeof Table>);\n\n  // Preset sizes.\n  if (jsonSchema) {\n    const schema = JsonSchema.toEffectSchema(jsonSchema);\n    const properties = SchemaAST.getPropertySignatures(schema.ast);\n    for (const property of properties) {\n      const name = property.name.toString() as JsonPath;\n      if (sizes?.[name]) {\n        table.sizes[name] = sizes[name];\n        continue;\n      }\n\n      Match.type<SchemaAST.AST>().pipe(\n        Match.when({ _tag: 'BooleanKeyword' }, () => {\n          table.sizes[name] = 100;\n        }),\n        Match.when({ _tag: 'NumberKeyword' }, () => {\n          table.sizes[name] = 100;\n        }),\n        Match.orElse(() => {\n          // Noop.\n        }),\n      )(property.type);\n    }\n  }\n\n  return table;\n};\n"],
-  "mappings": ";;;;;;;AAAA;;;;;AAIA,YAAYA,WAAW;AACvB,YAAYC,YAAY;AACxB,YAAYC,eAAe;AAE3B,SAASC,YAAYC,YAAYC,KAAKC,KAAKC,YAAY;AACvD,SAASC,YAAY;AACrB,SAASC,qBAAyDC,uBAAuB;AACzF,SAASC,sBAAsB;AAExB,IAAMC,QAAeC,cAAO;EACjCC,MAAaC,cAAOC,KAAYC,eAAQ;EAExCC,MAAMC,IAAIA,IAAIC,KAAKA,IAAI,EAAEJ,KAAKK,oBAAoBC,IAAI,KAAA,CAAA;EAEtDC,OAAcC,cAAO;;IAEnBC,KAAYV;IACZW,OAAcC;EAChB,CAAA,EAAGX,KAAYY,gBAASP,oBAAoBC,IAAI,KAAA,CAAA;AAClD,CAAA,EAAGN,KACDa,KAAKC,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACAC,gBAAgBX,IAAI;EAAC;CAAO,GAC5BY,eAAeZ,IAAI,IAAA,GACnBa,WAAWC,eAAed,IAAI;EAC5Be,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AAgBK,IAAMC,OAAO,CAAC,EAAEzB,MAAMS,QAAQ,CAAC,GAAGL,MAAMsB,WAAU,MAAa;AACpE,QAAMC,QAAQC,IAAIH,KAAK3B,OAAO;IAAEE;IAAMI,MAAMC,IAAIoB,KAAKrB,IAAAA;IAAOK;EAAM,CAAA;AAGlE,MAAIiB,YAAY;AACd,UAAMG,SAASC,WAAWC,eAAeL,UAAAA;AACzC,UAAMM,aAAuBC,gCAAsBJ,OAAOK,GAAG;AAC7D,eAAWC,YAAYH,YAAY;AACjC,YAAMhC,QAAOmC,SAASnC,KAAKoC,SAAQ;AACnC,UAAI3B,QAAQT,KAAAA,GAAO;AACjB2B,cAAMlB,MAAMT,KAAAA,IAAQS,MAAMT,KAAAA;AAC1B;MACF;AAEAqC,MAAMC,WAAI,EAAkBpC,KACpBqC,WAAK;QAAEC,MAAM;MAAiB,GAAG,MAAA;AACrCb,cAAMlB,MAAMT,KAAAA,IAAQ;MACtB,CAAA,GACMuC,WAAK;QAAEC,MAAM;MAAgB,GAAG,MAAA;AACpCb,cAAMlB,MAAMT,KAAAA,IAAQ;MACtB,CAAA,GACMyC,aAAO,MAAA;MAEb,CAAA,CAAA,EACAN,SAASG,IAAI;IACjB;EACF;AAEA,SAAOX;AACT;",
-  "names": ["Match", "Schema", "SchemaAST", "Annotation", "JsonSchema", "Obj", "Ref", "Type", "View", "FormInputAnnotation", "LabelAnnotation", "ViewAnnotation", "Table", "Struct", "name", "String", "pipe", "optional", "view", "Ref", "View", "FormInputAnnotation", "set", "sizes", "Record", "key", "value", "Number", "mutable", "Type", "object", "typename", "version", "LabelAnnotation", "ViewAnnotation", "Annotation", "IconAnnotation", "icon", "hue", "make", "jsonSchema", "table", "Obj", "schema", "JsonSchema", "toEffectSchema", "properties", "getPropertySignatures", "ast", "property", "toString", "Match", "type", "when", "_tag", "orElse"]
-}