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

package/src/testing/useTestTableModel.ts

@@ -2,40 +2,52 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useCallback, useMemo, useRef } from 'react';
+import type * as Schema from 'effect/Schema';
+import { type RefObject, useCallback, useMemo, useRef } from 'react';
 
-import { isMutable, toJsonSchema } from '@dxos/echo-schema';
+import { isMutable } from '@dxos/echo/internal';
 import { useGlobalFilteredObjects } from '@dxos/plugin-search';
 import { faker } from '@dxos/random';
-import { useClient } from '@dxos/react-client';
-import { Filter, useQuery, useSchema } from '@dxos/react-client/echo';
+import { type Client, useClient } from '@dxos/react-client';
+import { Filter, type Space, useQuery, useSchema } from '@dxos/react-client/echo';
 import { useClientProvider } from '@dxos/react-client/testing';
-import { DataType, ProjectionModel } from '@dxos/schema';
+import { type ProjectionModel, getTypenameFromQuery } from '@dxos/schema';
 
 import { type TableController } from '../components';
-import { useAddRow, useTableModel } from '../hooks';
-import { TablePresentation } from '../model';
+import { useAddRow, useProjectionModel, useTableModel } from '../hooks';
+import { type TableModel, TablePresentation } from '../model';
+import { Table } from '../types';
 
 faker.seed(0); // NOTE(ZaymonFC): Required for smoke tests.
 
+export type TestTableModel = {
+  schema: Schema.Schema.AnyNoContext | undefined;
+  table: Table.Table | undefined;
+  projection: ProjectionModel | undefined;
+  tableRef: RefObject<TableController | null>;
+  model: TableModel | undefined;
+  presentation: TablePresentation | undefined;
+  space: Space | undefined;
+  client: Client | undefined;
+  handleInsertRow: () => void;
+  handleSaveView: () => void;
+  handleDeleteRows: (rowIndex: number, objects: any[]) => void;
+  handleDeleteColumn: (fieldId: string) => void;
+};
+
 /**
  * Custom hook to create and manage a test table model for storybook demonstrations.
  * Provides table data, schema, and handlers for table operations.
  */
-export const useTestTableModel = () => {
+export const useTestTableModel = (): TestTableModel => {
   const client = useClient();
   const { space } = useClientProvider();
 
-  const views = useQuery(space, Filter.type(DataType.View));
-  const view = useMemo(() => views.at(0), [views]);
-  const schema = useSchema(client, space, view?.query.typename);
-  const jsonSchema = useMemo(() => (schema ? toJsonSchema(schema) : undefined), [schema]);
-
-  const projection = useMemo(() => {
-    if (schema && view?.projection) {
-      return new ProjectionModel(toJsonSchema(schema), view.projection);
-    }
-  }, [schema, view?.projection]);
+  const tables = useQuery(space, 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(client, space, typename);
+  const projection = useProjectionModel(schema, table);
 
   const features = useMemo(
     () => ({
@@ -79,8 +91,7 @@ export const useTestTableModel = () => {
   );
 
   const model = useTableModel({
-    view,
-    schema: jsonSchema,
+    object: table,
     projection,
     features,
     rows: filteredObjects,
@@ -94,7 +105,7 @@ export const useTestTableModel = () => {
   const handleInsertRow = useCallback(() => {
     const insertResult = model?.insertRow();
     tableRef.current?.handleInsertRowResult?.(insertResult);
-  }, [model, tableRef.current]);
+  }, [model]);
 
   const handleSaveView = useCallback(() => {
     model?.saveView();
@@ -108,7 +119,7 @@ export const useTestTableModel = () => {
 
   return {
     schema,
-    view,
+    table,
     projection,
     tableRef,
     model,

package/src/translations.ts

@@ -14,8 +14,8 @@ export const translations = [
         'create object label': 'Create table',
         'table name placeholder': 'Table name',
         'settings title': 'Table settings',
-        'table schema label': 'Record type',
-        'new schema': 'New record type',
+        'table schema label': 'Type',
+        'new schema': 'New type',
         'continue label': 'Continue',
         'create stack section label': 'Create table',
         'add row label': 'Add row',

package/src/types/Table.ts

@@ -0,0 +1,89 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Match from 'effect/Match';
+import * as Schema from 'effect/Schema';
+
+import { Obj, Ref, Type } from '@dxos/echo';
+import { FormInputAnnotation, type JsonPath, type JsonSchemaType, LabelAnnotation } from '@dxos/echo/internal';
+import { type SimpleType } from '@dxos/effect';
+import { View, ViewAnnotation, getSchemaProperties } from '@dxos/schema';
+
+const TableSchema = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+
+  view: Type.Ref(View.View).pipe(FormInputAnnotation.set(false)),
+
+  sizes: Schema.Record({
+    // TODO(wittjosiah): Should be JsonPath.
+    key: Schema.String,
+    value: Schema.Number,
+  }).pipe(Schema.mutable, FormInputAnnotation.set(false)),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/Table',
+    version: '0.2.0',
+  }),
+  LabelAnnotation.set(['name']),
+  ViewAnnotation.set(true),
+);
+
+export interface Table extends Schema.Schema.Type<typeof TableSchema> {}
+export interface TableEncoded extends Schema.Schema.Encoded<typeof TableSchema> {}
+export const Table: Schema.Schema<Table, TableEncoded> = TableSchema;
+
+type MakeProps = Omit<Partial<Obj.MakeProps<typeof Table>>, 'view'> & {
+  view: View.View;
+  /** Required to auto-size columns. */
+  jsonSchema?: JsonSchemaType;
+};
+
+/**
+ * Make a table as a view of a data set.
+ */
+export const make = ({ name, sizes = {}, view, jsonSchema }: MakeProps): Table => {
+  const table = Obj.make(Table, { name, view: Ref.make(view), sizes });
+
+  // Preset sizes.
+  if (jsonSchema) {
+    const schema = Type.toEffectSchema(jsonSchema);
+    const properties = getSchemaProperties(schema.ast, {});
+    for (const property of properties) {
+      if (sizes?.[property.name]) {
+        table.sizes[property.name] = sizes[property.name];
+        continue;
+      }
+
+      Match.type<SimpleType>().pipe(
+        Match.when('boolean', () => {
+          table.sizes[property.name as JsonPath] = 100;
+        }),
+        Match.when('number', () => {
+          table.sizes[property.name as JsonPath] = 100;
+        }),
+        Match.orElse(() => {
+          // Noop.
+        }),
+      )(property.type);
+    }
+  }
+
+  return table;
+};
+
+//
+// V1
+//
+
+export const TableV1 = Schema.Struct({
+  sizes: Schema.Record({
+    key: Schema.String,
+    value: Schema.Number,
+  }).pipe(Schema.mutable),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/Table',
+    version: '0.1.0',
+  }),
+);

package/src/types/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * as Table from './schema';
+export * as Table from './Table';

package/src/util/dynamic-table.ts

@@ -2,16 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
+import type * as Schema from 'effect/Schema';
 
-import { Obj } from '@dxos/echo';
-import { getTypename, toJsonSchema } from '@dxos/echo-schema';
-import type { JsonSchemaType, SortDirectionType } from '@dxos/echo-schema';
+import { Filter, type JsonSchema, Obj, Query, Ref, Type } from '@dxos/echo';
 import {
-  type DataType,
   ProjectionModel,
   type SchemaPropertyDefinition,
-  createView,
+  type SortDirectionType,
+  View,
   getSchemaFromPropertyDefinitions,
 } from '@dxos/schema';
 
@@ -38,14 +36,14 @@ export const getBaseSchema = ({
 }: {
   typename?: string;
   properties?: TablePropertyDefinition[];
-  jsonSchema?: JsonSchemaType;
+  jsonSchema?: JsonSchema.JsonSchema;
   schema?: Schema.Schema.AnyNoContext;
-}): { typename: string; jsonSchema: JsonSchemaType } => {
+}): { typename: string; jsonSchema: JsonSchema.JsonSchema } => {
   if (typename && properties) {
     const schema = getSchemaFromPropertyDefinitions(typename, properties);
     return { typename: schema.typename, jsonSchema: schema.jsonSchema };
   } else if (schema) {
-    return { typename: getTypename(schema)!, jsonSchema: toJsonSchema(schema) };
+    return { typename: Type.getTypename(schema)!, jsonSchema: Type.toJsonSchema(schema) };
   } else if (typename && jsonSchema) {
     return { typename, jsonSchema };
   } else {
@@ -54,32 +52,30 @@ export const getBaseSchema = ({
 };
 
 export const makeDynamicTable = ({
-  typename,
   jsonSchema,
   properties,
 }: {
-  typename: string;
-  jsonSchema: JsonSchemaType;
+  jsonSchema: JsonSchema.JsonSchema;
   properties?: TablePropertyDefinition[];
-}): { projection: ProjectionModel; view: DataType.View } => {
-  const table = Obj.make(Table.Table, { sizes: {} });
-  const view = createView({
-    typename,
+}): { projection: ProjectionModel; object: Table.Table } => {
+  const view = View.make({
+    query: Query.select(Filter.everything()),
     jsonSchema,
-    presentation: table,
     ...(properties && { fields: properties.map((property) => property.name) }),
   });
+  const object = Obj.make(Table.Table, { view: Ref.make(view), sizes: {} });
 
   const projection = new ProjectionModel(jsonSchema, view.projection);
+  projection.normalizeView();
   if (properties && projection.fields) {
-    setProperties(view, projection, table, properties);
+    setProperties(view, projection, object, properties);
   }
 
-  return { projection, view };
+  return { projection, object };
 };
 
 const setProperties = (
-  view: DataType.View,
+  view: View.View,
   projection: ProjectionModel,
   table: Table.Table,
   properties: TablePropertyDefinition[],
@@ -101,7 +97,7 @@ const setProperties = (
 
       if (property.sort) {
         const fieldId = field.id;
-        view.query.sort = [{ fieldId, direction: property.sort }];
+        view.sort = [{ fieldId, direction: property.sort }];
       }
     }
   }

package/src/util/schema.ts

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
-import { TypeLiteral, isTypeLiteral } from 'effect/SchemaAST';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 
 /**
  * Creates a narrowed schema from an original schema that only includes
@@ -20,14 +20,14 @@ export const narrowSchema = <S extends Schema.Schema.AnyNoContext>(
 ): Schema.Schema<unknown, unknown> | undefined => {
   const ast = (schema as any)?.ast;
 
-  if (isTypeLiteral(ast)) {
+  if (SchemaAST.isTypeLiteral(ast)) {
     // Filter property signatures that match any of the provided paths
     const propertySignatures = ast.propertySignatures.filter((signature) => paths.includes(signature.name.toString()));
 
     // If we found at least one matching property
     if (propertySignatures.length > 0) {
       // Create a new TypeLiteral with only the matching properties
-      const narrowType = new TypeLiteral(propertySignatures, []);
+      const narrowType = new SchemaAST.TypeLiteral(propertySignatures, []);
       return Schema.make(narrowType);
     }
   }

package/dist/lib/browser/chunk-63UUF4IG.mjs

@@ -1,66 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/types/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  Table: () => Table,
-  make: () => make,
-  makeView: () => makeView
-});
-import { Schema } from "effect";
-import { Match } from "effect";
-import { Obj, Type } from "@dxos/echo";
-import { JsonPath, toEffectSchema } from "@dxos/echo-schema";
-import { ViewAnnotation } from "@dxos/echo-schema";
-import { createViewFromSpace, getSchemaProperties } from "@dxos/schema";
-var Table = Schema.Struct({
-  sizes: Schema.Record({
-    key: JsonPath,
-    value: Schema.Number
-  }).pipe(Schema.mutable)
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/Table",
-  version: "0.1.0"
-}), ViewAnnotation.set(true));
-var make = (props = {}) => Obj.make(Table, {
-  sizes: {},
-  ...props
-});
-var makeView = async ({ sizes, ...props }) => {
-  const table = Obj.make(Table, {
-    sizes: {}
-  });
-  const { jsonSchema, view } = await createViewFromSpace({
-    ...props,
-    presentation: table
-  });
-  const schema = toEffectSchema(jsonSchema);
-  const shouldIncludeId = props.fields?.find((field) => field === "id") !== void 0;
-  const properties = getSchemaProperties(schema.ast, {}, shouldIncludeId);
-  for (const property of properties) {
-    if (sizes?.[property.name]) {
-      table.sizes[property.name] = sizes[property.name];
-      continue;
-    }
-    Match.type().pipe(Match.when("boolean", () => {
-      table.sizes[property.name] = 100;
-    }), Match.when("number", () => {
-      table.sizes[property.name] = 100;
-    }), Match.orElse(() => {
-    }))(property.type);
-  }
-  return {
-    jsonSchema,
-    schema,
-    view
-  };
-};
-
-export {
-  schema_exports
-};
-//# sourceMappingURL=chunk-63UUF4IG.mjs.map

package/dist/lib/browser/chunk-63UUF4IG.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types/schema.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Schema } from 'effect';\nimport { Match } from 'effect';\n\nimport { Obj, Type } from '@dxos/echo';\nimport { JsonPath, type JsonSchemaType, toEffectSchema } from '@dxos/echo-schema';\nimport { ViewAnnotation } from '@dxos/echo-schema';\nimport { type SimpleType } from '@dxos/effect';\nimport { type CreateViewFromSpaceProps, type DataType, createViewFromSpace, getSchemaProperties } from '@dxos/schema';\n\nexport const Table = Schema.Struct({\n  sizes: Schema.Record({\n    key: JsonPath,\n    value: Schema.Number,\n  }).pipe(Schema.mutable),\n}).pipe(\n  Type.Obj({\n    typename: 'dxos.org/type/Table',\n    version: '0.1.0',\n  }),\n  ViewAnnotation.set(true),\n);\n\nexport type Table = Schema.Schema.Type<typeof Table>;\n\n/**\n * Make a table view.\n */\nexport const make = (props: Partial<Obj.MakeProps<typeof Table>> = {}) => Obj.make(Table, { sizes: {}, ...props });\n\ntype MakeViewProps = Omit<CreateViewFromSpaceProps, 'presentation'> & {\n  sizes?: Record<string, number>;\n};\n\nexport const makeView = async ({\n  sizes,\n  ...props\n}: MakeViewProps): Promise<{\n  jsonSchema: JsonSchemaType;\n  view: DataType.View;\n  schema: ReturnType<typeof toEffectSchema>;\n}> => {\n  const table = Obj.make(Table, { sizes: {} });\n  const { jsonSchema, view } = await createViewFromSpace({ ...props, presentation: table });\n\n  // Preset sizes.\n  const schema = toEffectSchema(jsonSchema);\n  const shouldIncludeId = props.fields?.find((field) => field === 'id') !== undefined;\n  const properties = getSchemaProperties(schema.ast, {}, shouldIncludeId);\n  for (const property of properties) {\n    if (sizes?.[property.name]) {\n      table.sizes[property.name as JsonPath] = sizes[property.name];\n      continue;\n    }\n\n    Match.type<SimpleType>().pipe(\n      Match.when('boolean', () => {\n        table.sizes[property.name as JsonPath] = 100;\n      }),\n      Match.when('number', () => {\n        table.sizes[property.name as JsonPath] = 100;\n      }),\n      Match.orElse(() => {\n        // Noop.\n      }),\n    )(property.type);\n  }\n\n  return { jsonSchema, schema, view };\n};\n"],
-  "mappings": ";;;;;;;AAAA;;;;;;AAIA,SAASA,cAAc;AACvB,SAASC,aAAa;AAEtB,SAASC,KAAKC,YAAY;AAC1B,SAASC,UAA+BC,sBAAsB;AAC9D,SAASC,sBAAsB;AAE/B,SAAuDC,qBAAqBC,2BAA2B;AAEhG,IAAMC,QAAQC,OAAOC,OAAO;EACjCC,OAAOF,OAAOG,OAAO;IACnBC,KAAKC;IACLC,OAAON,OAAOO;EAChB,CAAA,EAAGC,KAAKR,OAAOS,OAAO;AACxB,CAAA,EAAGD,KACDE,KAAKC,IAAI;EACPC,UAAU;EACVC,SAAS;AACX,CAAA,GACAC,eAAeC,IAAI,IAAA,CAAA;AAQd,IAAMC,OAAO,CAACC,QAA8C,CAAC,MAAMN,IAAIK,KAAKjB,OAAO;EAAEG,OAAO,CAAC;EAAG,GAAGe;AAAM,CAAA;AAMzG,IAAMC,WAAW,OAAO,EAC7BhB,OACA,GAAGe,MAAAA,MACW;AAKd,QAAME,QAAQR,IAAIK,KAAKjB,OAAO;IAAEG,OAAO,CAAC;EAAE,CAAA;AAC1C,QAAM,EAAEkB,YAAYC,KAAI,IAAK,MAAMC,oBAAoB;IAAE,GAAGL;IAAOM,cAAcJ;EAAM,CAAA;AAGvF,QAAMK,SAASC,eAAeL,UAAAA;AAC9B,QAAMM,kBAAkBT,MAAMU,QAAQC,KAAK,CAACC,UAAUA,UAAU,IAAA,MAAUC;AAC1E,QAAMC,aAAaC,oBAAoBR,OAAOS,KAAK,CAAC,GAAGP,eAAAA;AACvD,aAAWQ,YAAYH,YAAY;AACjC,QAAI7B,QAAQgC,SAASC,IAAI,GAAG;AAC1BhB,YAAMjB,MAAMgC,SAASC,IAAI,IAAgBjC,MAAMgC,SAASC,IAAI;AAC5D;IACF;AAEAC,UAAMC,KAAI,EAAe7B,KACvB4B,MAAME,KAAK,WAAW,MAAA;AACpBnB,YAAMjB,MAAMgC,SAASC,IAAI,IAAgB;IAC3C,CAAA,GACAC,MAAME,KAAK,UAAU,MAAA;AACnBnB,YAAMjB,MAAMgC,SAASC,IAAI,IAAgB;IAC3C,CAAA,GACAC,MAAMG,OAAO,MAAA;IAEb,CAAA,CAAA,EACAL,SAASG,IAAI;EACjB;AAEA,SAAO;IAAEjB;IAAYI;IAAQH;EAAK;AACpC;",
-  "names": ["Schema", "Match", "Obj", "Type", "JsonPath", "toEffectSchema", "ViewAnnotation", "createViewFromSpace", "getSchemaProperties", "Table", "Schema", "Struct", "sizes", "Record", "key", "JsonPath", "value", "Number", "pipe", "mutable", "Type", "Obj", "typename", "version", "ViewAnnotation", "set", "make", "props", "makeView", "table", "jsonSchema", "view", "createViewFromSpace", "presentation", "schema", "toEffectSchema", "shouldIncludeId", "fields", "find", "field", "undefined", "properties", "getSchemaProperties", "ast", "property", "name", "Match", "type", "when", "orElse"]
-}