@dxos/react-ui-table 0.7.5-main.499c70c → 0.7.5-main.6a330ac

package/src/model/table-sorting.ts

@@ -0,0 +1,215 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { computed, signal, type Signal, type ReadonlySignal } from '@preact/signals-core';
+import orderBy from 'lodash.orderby';
+
+import { getValue, FormatEnum, TypeEnum, type SortDirectionType, type FieldSortType } from '@dxos/echo-schema';
+import { formatForDisplay } from '@dxos/react-ui-form';
+import type { PropertyType, FieldType, ViewProjection, ViewType } from '@dxos/schema';
+
+import { type BaseTableRow } from './table-model';
+
+/**
+ * Represents the local sort state.
+ * - undefined: No local sort set, fallback to view sort.
+ * - cleared: Sort explicitly cleared by user.
+ * - active: Active local sort with sort configuration.
+ */
+type LocalSort = { type: 'cleared' } | { type: 'active'; sort: FieldSortType } | undefined;
+
+/**
+ * Manages table sorting functionality through display and data index mapping.
+ *
+ * When a table is sorted, rows visually reorder but we need to maintain references
+ * to the original data positions. This is handled through two types of indices:
+ *
+ * - Display indices: The visual positions after sorting
+ * - Data indices: The original positions in the source data
+ *
+ * The _displayToDataIndex map maintains these relationships, enabling lookups
+ * between visual and source positions.
+ *
+ * Example mapping between display and data indices:
+ *
+ * Original Data:        Sorted Display:       Mapping: (Display → Data)
+ * ┌──────────────┐      ┌──────────────┐      ┌────────┐
+ * │ 0: "Banana"  │  =>  │ 0: "Apple"   │  =>  │ 0 => 1 │
+ * │ 1: "Apple"   │  =>  │ 1: "Banana"  │  =>  │ 1 => 0 │
+ * │ 2: "Cherry"  │  =>  │ 2: "Cherry"  │  =>  │ 2 => 2 │
+ * └──────────────┘      └──────────────┘      └────────┘
+ */
+export class TableSorting<T extends BaseTableRow> {
+  private readonly _displayToDataIndex = new Map<number, number>();
+  private readonly _rows: Signal<T[]>;
+  private readonly _localSort = signal<LocalSort>(undefined);
+  private readonly _isDirty: ReadonlySignal<boolean>;
+  public readonly sortedRows: ReadonlySignal<T[]>;
+
+  constructor(
+    rows: Signal<T[]>,
+    private readonly _view: ViewType | undefined,
+    private readonly _projection: ViewProjection,
+  ) {
+    this._rows = rows;
+    this._isDirty = computed(() => {
+      const local = this._localSort.value;
+      const viewSort = this._view?.query.sort?.[0];
+      if (local?.type === 'cleared') {
+        return viewSort !== undefined;
+      }
+      if (local?.type === 'active') {
+        if (!viewSort) {
+          return true;
+        }
+        return local.sort.fieldId !== viewSort.fieldId || local.sort.direction !== viewSort.direction;
+      }
+      return false;
+    });
+    this.sortedRows = this.initialiseSortedRows();
+  }
+
+  /**
+   * @reactive
+   * @returns Local sort if present, falls back to view sort.
+   */
+  public get sorting(): FieldSortType | undefined {
+    const local = this._localSort.value;
+    if (local?.type === 'cleared') {
+      return undefined;
+    }
+    if (local?.type === 'active') {
+      return local.sort;
+    }
+    return this._view?.query.sort?.[0];
+  }
+
+  /**
+   * @reactive
+   * @returns Whether local sort differs from view sort.
+   */
+  public get isDirty(): boolean {
+    return this._isDirty.value;
+  }
+
+  public getDataIndex(displayIndex: number): number {
+    return this._displayToDataIndex.get(displayIndex) ?? displayIndex;
+  }
+
+  public setSort(fieldId: string, direction: SortDirectionType): void {
+    this._localSort.value = {
+      type: 'active',
+      sort: { fieldId, direction },
+    };
+  }
+
+  public toggleSort(fieldId: string): void {
+    if (!this._view || !this.sorting || this.sorting.fieldId !== fieldId) {
+      return;
+    }
+
+    switch (this.sorting.direction) {
+      case 'asc': {
+        this.setSort(fieldId, 'desc');
+        break;
+      }
+      case 'desc': {
+        this.setSort(fieldId, 'asc');
+        break;
+      }
+    }
+  }
+
+  public clearSort(): void {
+    this._localSort.value = { type: 'cleared' };
+  }
+
+  public save(): void {
+    if (this._view && this._localSort.value !== undefined) {
+      if (this._localSort.value.type === 'active') {
+        this._view.query.sort = [this._localSort.value.sort];
+      } else {
+        this._view.query.sort = [];
+      }
+      this._localSort.value = undefined;
+    }
+  }
+
+  //
+  // Initialisation.
+  //
+
+  private initialiseSortedRows(): ReadonlySignal<T[]> {
+    return computed(() => {
+      this._displayToDataIndex.clear();
+      const sort = this.sorting;
+      if (!sort || !this._view) {
+        return this._rows.value;
+      }
+
+      const field = this._view.fields.find((f) => f.id === sort.fieldId);
+      if (!field) {
+        return this._rows.value;
+      }
+
+      const { props } = this._projection.getFieldProjection(field.id);
+
+      const dataWithIndices = this._rows.value.map((item, index) => {
+        const sortValue = this.getSortValue(props, field, item);
+        const isEmpty = !(props.type === TypeEnum.Boolean) && (sortValue == null || sortValue === '');
+
+        return { item, index, value: sortValue, isEmpty };
+      });
+
+      const ordered = orderBy(dataWithIndices, ['isEmpty', 'value'], ['asc', sort.direction]);
+
+      ordered.forEach(({ index: dataIndex }, displayIndex) => {
+        if (displayIndex !== dataIndex) {
+          this._displayToDataIndex.set(displayIndex, dataIndex);
+        }
+      });
+
+      return ordered.map(({ item }) => item);
+    });
+  }
+
+  private getSortValue(props: PropertyType, field: FieldType, item: T) {
+    const { type, format } = props;
+    const value = getValue(item, field.path);
+
+    if (type === TypeEnum.Boolean) {
+      return !!value; // Coerce null/undefined to false for booleans.
+    }
+    if (type === TypeEnum.Number) {
+      return value;
+    }
+    if (value == null) {
+      return value;
+    }
+
+    /**
+     * For single select fields, the sort value is determined by the index of the option in the
+     * options array. This ensures sort order matches the configured option order.
+     */
+    if (format === FormatEnum.SingleSelect) {
+      const options = props.options;
+      if (!options) {
+        return undefined;
+      }
+
+      const option = options.find((option) => option.id === value);
+      return option ? options.indexOf(option) : undefined;
+    }
+
+    // TODO(ZaymonFC): Should we format this returned value for display based on the referenced prop format?
+    //   Right now we're going to be sorting based on the raw values.
+    //   Maybe we need to recurse this function with the referenced prop format and field?
+    if (format === FormatEnum.Ref && field.referencePath) {
+      const refValue = getValue(value.target, field.referencePath);
+      return refValue;
+    }
+
+    return formatForDisplay({ type, format, value });
+  }
+}

package/src/playwright/smoke.spec.ts

@@ -13,17 +13,17 @@ const storyUrl = `http://localhost:9009/iframe.html?id=${storyId}&viewMode=story
 
 // NOTE(ZaymonFC): This test suite relies on the faker seed being set to 0 in the story.
 test.describe('Table', () => {
-  test('Loads', async ({ browser }) => {
+  test('Loads', async ({ browser, browserName }) => {
+    test.skip(browserName === 'webkit');
     const { page } = await setupPage(browser, { url: storyUrl });
     const table = new TableManager(page);
 
-    // (name, email, salary, manager) * 10 rows.
     await table.grid.ready();
-    await expect(table.grid.cellsWithinPlane('grid')).toHaveCount(40);
     await page.close();
   });
 
-  test('sort', async ({ browser }) => {
+  test('sort', async ({ browser, browserName }) => {
+    test.skip(browserName === 'webkit');
     const { page } = await setupPage(browser, { url: storyUrl });
     const table = new TableManager(page);
 
@@ -38,7 +38,8 @@ test.describe('Table', () => {
     await page.close();
   });
 
-  test('selection', async ({ browser }) => {
+  test('selection', async ({ browser, browserName }) => {
+    test.skip(browserName === 'webkit');
     const { page } = await setupPage(browser, { url: storyUrl });
     const table = new TableManager(page);
 
@@ -58,7 +59,8 @@ test.describe('Table', () => {
     await page.close();
   });
 
-  test('delete row', async ({ browser }) => {
+  test('delete row', async ({ browser, browserName }) => {
+    test.skip(browserName === 'webkit');
     const { page } = await setupPage(browser, { url: storyUrl });
     const table = new TableManager(page);
 
@@ -68,7 +70,8 @@ test.describe('Table', () => {
     await page.close();
   });
 
-  test('delete row--select all', async ({ browser }) => {
+  test('delete row--select all', async ({ browser, browserName }) => {
+    test.skip(browserName === 'webkit');
     const { page } = await setupPage(browser, { url: storyUrl });
     const table = new TableManager(page);
 
@@ -84,7 +87,8 @@ test.describe('Table', () => {
     await page.close();
   });
 
-  test('delete column', async ({ browser }) => {
+  test('delete column', async ({ browser, browserName }) => {
+    test.skip(browserName === 'webkit');
     const { page } = await setupPage(browser, { url: storyUrl });
     const table = new TableManager(page);
 
@@ -110,7 +114,8 @@ test.describe('Table', () => {
 
   // Rest of add column test remains the same as it's a more complex flow.
   // TODO(ZaymonFC): Restore this after fixing format selection.
-  test('add column', async ({ browser }) => {
+  test('add column', async ({ browser, browserName }) => {
+    test.skip(browserName === 'webkit');
     const { page } = await setupPage(browser, { url: storyUrl });
     const table = new TableManager(page);
 
@@ -123,25 +128,42 @@ test.describe('Table', () => {
     await page.close();
   });
 
-  test('pick reference', async ({ browser }) => {
+  test('reference > reference / create new object', async ({ browser, browserName }) => {
+    test.skip(browserName === 'webkit');
     const { page } = await setupPage(browser, { url: storyUrl });
     const table = new TableManager(page);
 
     await table.grid.ready();
 
+    // Reference existing object.
+    // Scroll over to the manager column.
     await table.grid.panByWheel(10000, 0);
 
     await table.grid.cell(4, 0, 'grid').click();
     await page.keyboard.press('A');
+    await page.keyboard.press('N');
     await page.getByRole('option', { name: 'Anita Mayer' }).click();
 
     // Assert that the value is shown in the cell.
-    await expect(page.getByRole('gridcell', { name: 'Anita Mayer' })).toBeVisible();
+    await expect(page.getByRole('gridcell', { name: 'Anita Mayer' }).first()).toBeVisible();
+
+    // Create new object.
+    await table.grid.cell(4, 1, 'grid').click();
+    await page.keyboard.type('t');
+    await page.keyboard.type('e');
+    await page.keyboard.type('s');
+    await page.keyboard.type('t');
+    await page.getByText('Create new object', { exact: false }).click();
+    await page.getByTestId('save-button').click();
+
+    // Scroll to the left.
+    await page.getByRole('gridcell', { name: 'test' }).first().click();
 
     await page.close();
   });
 
-  test('test toggles', async ({ browser }) => {
+  test('test toggles', async ({ browser, browserName }) => {
+    test.skip(browserName === 'webkit');
     const { page } = await setupPage(browser, { url: storyUrl });
     const table = new TableManager(page);
 
@@ -151,7 +173,7 @@ test.describe('Table', () => {
     await page.getByTestId('table-switch').nth(7).click();
 
     // Test that checks are durable in the data model by sorting.
-    await table.sortColumn(1, 'descending');
+    await table.sortColumn(3, 'descending');
 
     // Assert the first two switch checkboxes are checked.
     await expect(page.getByTestId('table-switch').first()).toBeChecked();

package/src/translations.ts

@@ -16,7 +16,7 @@ export default [
         'new schema': 'New schema',
         'continue label': 'Continue',
         'create stack section label': 'Create table',
-        'add row': 'Add row',
+        'add row label': 'Add row',
         'create comment': 'Create thread',
         'column action sort descending': 'Sort Descending',
         'column action sort ascending': 'Sort Ascending',
@@ -28,6 +28,7 @@ export default [
         'column deleted label': 'Column deleted',
         'new column button label': 'Create column',
         'create new object label': 'Create new object “{{text}}”',
+        'save view label': 'Save changes to view',
       },
     },
   },

package/src/types/table.ts

@@ -2,8 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Ref, ObjectId, S, TypedObject } from '@dxos/echo-schema';
-import { ThreadType } from '@dxos/plugin-space';
+import { Ref, ObjectId, S, TypedObject, Expando } from '@dxos/echo-schema';
+// import { ThreadType } from '@dxos/plugin-space/types';
 import { ViewType } from '@dxos/schema';
 
 export const TableSchema = S.Struct({
@@ -11,7 +11,7 @@ export const TableSchema = S.Struct({
   name: S.optional(S.String),
   view: S.optional(Ref(ViewType)),
   // TODO(burdon): Should not import from plugin. Either factor out type or use reverse deps when supported.
-  threads: S.optional(S.Array(Ref(ThreadType))),
+  threads: S.optional(S.Array(Ref(Expando /* ThreadType */))), // TODO(dmaretskyi): Breaks edge because plugin-space depends on react-client.
 });
 
 // type TableType = S.Schema.Type<typeof TableSchema>;

package/src/util/table-buttons.ts

@@ -2,20 +2,22 @@
 // Copyright 2024 DXOS.org
 //
 
-export type TableButton = 'columnSettings' | 'rowMenu' | 'newColumn' | 'referencedCell';
+export type TableButton = 'columnSettings' | 'rowMenu' | 'newColumn' | 'referencedCell' | 'sort';
 
 export const BUTTON_IDENTIFIERS: { [K in TableButton]: string } = {
   columnSettings: 'data-table-column-settings-button',
   newColumn: 'data-table-new-column-button',
   referencedCell: 'data-table-ref-cell-button',
   rowMenu: 'data-table-row-menu-button',
+  sort: 'data-table-sort-button',
 } as const;
 
 type ButtonData =
   | { type: 'columnSettings'; fieldId: string }
   | { type: 'newColumn'; disabled?: boolean }
   | { type: 'referencedCell'; schemaId: string; targetId: string }
-  | { type: 'rowMenu'; rowIndex: number };
+  | { type: 'rowMenu'; rowIndex: number }
+  | { type: 'sort'; fieldId: string; direction?: 'asc' | 'desc' };
 
 const createButton = ({
   attr,
@@ -23,18 +25,21 @@ const createButton = ({
   disabled = false,
   icon,
   testId,
+  type = 'primary',
 }: {
   attr: string;
   data: Record<string, string>;
   disabled?: boolean;
   icon: string;
   testId: string;
+  type?: 'primary' | 'secondary';
 }) => {
   const dataAttrs = Object.entries(data)
     .map(([k, v]) => `${k}="${v}"`)
     .join(' ');
 
-  return `<button ${attr} data-testid="${testId}" class="ch-button is-6 pli-0.5 min-bs-0 absolute inset-block-1 inline-end-2" ${dataAttrs} ${disabled ? 'disabled' : ''}><svg><use href="/icons.svg#${icon}"/></svg></button>`;
+  const positionClass = type === 'primary' ? 'inline-end-2' : 'inline-end-9';
+  return `<button ${attr} data-testid="${testId}" class="dx-button is-6 pli-0.5 min-bs-0 absolute inset-block-1 ${positionClass}" ${dataAttrs} ${disabled ? 'disabled' : ''}><svg><use href="/icons.svg#${icon}"/></svg></button>`;
 };
 
 const addColumnButton = {
@@ -111,9 +116,34 @@ const rowMenuButton = {
   }),
 } as const;
 
+const sortButton = {
+  attr: BUTTON_IDENTIFIERS.sort,
+  icon: 'ph--sort-ascending--regular',
+  render: ({ fieldId, direction }: Omit<Extract<ButtonData, { type: 'sort' }>, 'type'>) => {
+    return createButton({
+      attr: BUTTON_IDENTIFIERS.sort,
+      icon: direction === 'desc' ? 'ph--sort-descending--regular' : 'ph--sort-ascending--regular',
+      data: {
+        'data-field-id': fieldId,
+        'data-direction': direction ?? '',
+      },
+      testId: 'table-sort-button',
+      // TODO(ZaymonFC): All buttons should be rendered into an absolutely positioned flex container.
+      // This is a bit hacky.
+      type: 'secondary',
+    });
+  },
+  getData: (el: HTMLElement): Extract<ButtonData, { type: 'sort' }> => ({
+    type: 'sort',
+    fieldId: el.getAttribute('data-field-id')!,
+    direction: el.getAttribute('data-direction') as 'asc' | 'desc' | undefined,
+  }),
+} as const;
+
 export const tableButtons = {
   addColumn: addColumnButton,
   columnSettings: columnSettingsButton,
   referencedCell: referencedCellButton,
   rowMenu: rowMenuButton,
+  sort: sortButton,
 } as const;

package/src/util/table-controls.ts

@@ -23,8 +23,8 @@ export const CONTROL_IDENTIFIERS = {
 } as const;
 
 const BASE_CLASSES = {
-  checkbox: 'absolute inset-block-[.375rem] inline-end-[.375rem] ch-checkbox',
-  switch: 'absolute inset-block-[.25rem] inline-end-[.25rem] ch-checkbox--switch',
+  checkbox: 'absolute inset-block-[.375rem] inline-end-[.375rem] dx-checkbox',
+  switch: 'absolute inset-block-[.25rem] inline-end-[.25rem] dx-checkbox--switch',
 } as const;
 
 const renderAttributes = (data: Record<string, string>) => {

package/src/util/table.ts

@@ -13,10 +13,9 @@ import {
   TypedObject,
   TypeEnum,
 } from '@dxos/echo-schema';
-import { log } from '@dxos/log';
 import { PublicKey } from '@dxos/react-client';
 import { create, makeRef, type Space } from '@dxos/react-client/echo';
-import { createFieldId, createView, ViewProjection } from '@dxos/schema';
+import { createFieldId, createView, getSchemaProperties, ViewProjection } from '@dxos/schema';
 
 import { type TableType } from '../types';
 
@@ -24,70 +23,104 @@ type InitialiseTableProps = {
   space: Space;
   table: TableType;
   initialRow?: boolean;
+  initialSchema?: string;
 };
 
+// TODO(ZaymonFC): Clean up the branching in this file.
+
 // TODO(burdon): Pass in type.
 // TODO(burdon): User should determine typename.
 export const initializeTable = async ({
   space,
   table,
   initialRow = true,
+  initialSchema,
 }: InitialiseTableProps): Promise<EchoSchema> => {
-  log('initializeTable', { table });
+  if (initialSchema) {
+    const schema = await space.db.schemaRegistry.query({ typename: initialSchema }).firstOrUndefined();
 
-  const ContactSchema = TypedObject({
-    typename: `example.com/type/${PublicKey.random().truncate()}`,
-    version: '0.1.0',
-  })({
-    name: S.optional(S.String).annotations({
-      [AST.TitleAnnotationId]: 'Name',
-    }),
-    active: S.optional(S.Boolean),
-    email: S.optional(Format.Email),
-    salary: S.optional(Format.Currency()).annotations({
-      [AST.TitleAnnotationId]: 'Salary',
-    }), // TODO(burdon): Should default to prop name?
-  });
+    if (!schema) {
+      throw new Error(`Schema not found: ${initialSchema}`);
+    }
 
-  const [contactSchema] = await space.db.schemaRegistry.register([ContactSchema]);
+    // We need to get the schema properties here. For now, only simple types and refs, not compound types
+    // are going to be supported.
+    const fields = getSchemaProperties(schema.ast)
+      .filter((prop) => prop.format !== FormatEnum.Ref)
+      .map((prop) => prop.name);
 
-  table.view = makeRef(
-    createView({
-      name: 'Test',
-      typename: contactSchema.typename,
-      jsonSchema: contactSchema.jsonSchema,
-      fields: ['name', 'active', 'email', 'salary'],
-    }),
-  );
+    table.view = makeRef(
+      createView({
+        // TODO(ZaymonFC): Don't hardcode name?
+        name: 'View',
+        typename: schema.typename,
+        jsonSchema: schema.jsonSchema,
+        fields,
+      }),
+    );
 
-  const projection = new ViewProjection(contactSchema, table.view.target!);
-  projection.setFieldProjection({
-    field: {
-      id: table.view.target!.fields.find((f) => f.path === 'salary')!.id,
-      path: 'salary' as JsonPath,
-      size: 150,
-    },
-  });
+    return schema;
+  } else {
+    const ContactSchema = TypedObject({
+      typename: `example.com/type/${PublicKey.random().truncate()}`,
+      version: '0.1.0',
+    })({
+      name: S.optional(S.String).annotations({
+        [AST.TitleAnnotationId]: 'Name',
+      }),
+      active: S.optional(S.Boolean),
+      email: S.optional(Format.Email),
+      salary: S.optional(Format.Currency()).annotations({
+        [AST.TitleAnnotationId]: 'Salary',
+      }), // TODO(burdon): Should default to prop name?
+    });
 
-  projection.setFieldProjection({
-    field: {
-      id: createFieldId(),
-      path: 'manager' as JsonPath,
-      referencePath: 'name' as JsonPath,
-    },
-    props: {
-      property: 'manager' as JsonProp,
-      type: TypeEnum.Ref,
-      format: FormatEnum.Ref,
-      referenceSchema: contactSchema.typename,
-      title: 'Manager',
-    },
-  });
+    const [contactSchema] = await space.db.schemaRegistry.register([ContactSchema]);
 
-  if (initialRow) {
-    // TODO(burdon): Last (first) row should not be in db and should be managed by the model.
-    space.db.add(create(contactSchema, {}));
-  }
+    table.view = makeRef(
+      createView({
+        name: 'View',
+        typename: contactSchema.typename,
+        jsonSchema: contactSchema.jsonSchema,
+        fields: ['name', 'email', 'salary', 'active'],
+      }),
+    );
+
+    const projection = new ViewProjection(contactSchema, table.view.target!);
+    projection.setFieldProjection({
+      field: {
+        id: table.view.target!.fields.find((f) => f.path === 'salary')!.id,
+        path: 'salary' as JsonPath,
+        size: 150,
+      },
+    });
+    projection.setFieldProjection({
+      field: {
+        id: table.view.target!.fields.find((f) => f.path === 'active')!.id,
+        path: 'active' as JsonPath,
+        size: 100,
+      },
+    });
 
-  return contactSchema;
+    projection.setFieldProjection({
+      field: {
+        id: createFieldId(),
+        path: 'manager' as JsonPath,
+        referencePath: 'name' as JsonPath,
+      },
+      props: {
+        property: 'manager' as JsonProp,
+        type: TypeEnum.Ref,
+        format: FormatEnum.Ref,
+        referenceSchema: contactSchema.typename,
+        title: 'Manager',
+      },
+    });
+    if (initialRow) {
+      // TODO(burdon): Last (first) row should not be in db and should be managed by the model.
+      space.db.add(create(contactSchema, {}));
+    }
+
+    return contactSchema;
+  }
 };

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types/table.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Ref, ObjectId, S, TypedObject } from '@dxos/echo-schema';\nimport { ThreadType } from '@dxos/plugin-space';\nimport { ViewType } from '@dxos/schema';\n\nexport const TableSchema = S.Struct({\n  id: ObjectId, // TODO(burdon): Where should this be?\n  name: S.optional(S.String),\n  view: S.optional(Ref(ViewType)),\n  // TODO(burdon): Should not import from plugin. Either factor out type or use reverse deps when supported.\n  threads: S.optional(S.Array(Ref(ThreadType))),\n});\n\n// type TableType = S.Schema.Type<typeof TableSchema>;\n\nexport class TableType extends TypedObject({\n  typename: 'dxos.org/type/Table',\n  version: '0.1.0',\n})(TableSchema.fields) {}\n"],
-  "mappings": ";AAIA,SAASA,KAAKC,UAAUC,GAAGC,mBAAmB;AAC9C,SAASC,kBAAkB;AAC3B,SAASC,gBAAgB;AAElB,IAAMC,cAAcC,EAAEC,OAAO;EAClCC,IAAIC;EACJC,MAAMJ,EAAEK,SAASL,EAAEM,MAAM;EACzBC,MAAMP,EAAEK,SAASG,IAAIC,QAAAA,CAAAA;;EAErBC,SAASV,EAAEK,SAASL,EAAEW,MAAMH,IAAII,UAAAA,CAAAA,CAAAA;AAClC,CAAA;AAIO,IAAMC,YAAN,cAAwBC,YAAY;EACzCC,UAAU;EACVC,SAAS;AACX,CAAA,EAAGjB,YAAYkB,MAAM,EAAA;AAAG;",
-  "names": ["Ref", "ObjectId", "S", "TypedObject", "ThreadType", "ViewType", "TableSchema", "S", "Struct", "id", "ObjectId", "name", "optional", "String", "view", "Ref", "ViewType", "threads", "Array", "ThreadType", "TableType", "TypedObject", "typename", "version", "fields"]
-}

package/dist/lib/node/chunk-YSBXNBDJ.cjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types/table.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Ref, ObjectId, S, TypedObject } from '@dxos/echo-schema';\nimport { ThreadType } from '@dxos/plugin-space';\nimport { ViewType } from '@dxos/schema';\n\nexport const TableSchema = S.Struct({\n  id: ObjectId, // TODO(burdon): Where should this be?\n  name: S.optional(S.String),\n  view: S.optional(Ref(ViewType)),\n  // TODO(burdon): Should not import from plugin. Either factor out type or use reverse deps when supported.\n  threads: S.optional(S.Array(Ref(ThreadType))),\n});\n\n// type TableType = S.Schema.Type<typeof TableSchema>;\n\nexport class TableType extends TypedObject({\n  typename: 'dxos.org/type/Table',\n  version: '0.1.0',\n})(TableSchema.fields) {}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAIA,yBAA8C;AAC9C,0BAA2B;AAC3B,oBAAyB;AAElB,IAAMA,cAAcC,qBAAEC,OAAO;EAClCC,IAAIC;EACJC,MAAMJ,qBAAEK,SAASL,qBAAEM,MAAM;EACzBC,MAAMP,qBAAEK,aAASG,wBAAIC,sBAAAA,CAAAA;;EAErBC,SAASV,qBAAEK,SAASL,qBAAEW,UAAMH,wBAAII,8BAAAA,CAAAA,CAAAA;AAClC,CAAA;AAIO,IAAMC,YAAN,kBAAwBC,gCAAY;EACzCC,UAAU;EACVC,SAAS;AACX,CAAA,EAAGjB,YAAYkB,MAAM,EAAA;AAAG;",
-  "names": ["TableSchema", "S", "Struct", "id", "ObjectId", "name", "optional", "String", "view", "Ref", "ViewType", "threads", "Array", "ThreadType", "TableType", "TypedObject", "typename", "version", "fields"]
-}

package/dist/lib/node-esm/chunk-6OH2NHUX.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types/table.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Ref, ObjectId, S, TypedObject } from '@dxos/echo-schema';\nimport { ThreadType } from '@dxos/plugin-space';\nimport { ViewType } from '@dxos/schema';\n\nexport const TableSchema = S.Struct({\n  id: ObjectId, // TODO(burdon): Where should this be?\n  name: S.optional(S.String),\n  view: S.optional(Ref(ViewType)),\n  // TODO(burdon): Should not import from plugin. Either factor out type or use reverse deps when supported.\n  threads: S.optional(S.Array(Ref(ThreadType))),\n});\n\n// type TableType = S.Schema.Type<typeof TableSchema>;\n\nexport class TableType extends TypedObject({\n  typename: 'dxos.org/type/Table',\n  version: '0.1.0',\n})(TableSchema.fields) {}\n"],
-  "mappings": ";;;AAIA,SAASA,KAAKC,UAAUC,GAAGC,mBAAmB;AAC9C,SAASC,kBAAkB;AAC3B,SAASC,gBAAgB;AAElB,IAAMC,cAAcC,EAAEC,OAAO;EAClCC,IAAIC;EACJC,MAAMJ,EAAEK,SAASL,EAAEM,MAAM;EACzBC,MAAMP,EAAEK,SAASG,IAAIC,QAAAA,CAAAA;;EAErBC,SAASV,EAAEK,SAASL,EAAEW,MAAMH,IAAII,UAAAA,CAAAA,CAAAA;AAClC,CAAA;AAIO,IAAMC,YAAN,cAAwBC,YAAY;EACzCC,UAAU;EACVC,SAAS;AACX,CAAA,EAAGjB,YAAYkB,MAAM,EAAA;AAAG;",
-  "names": ["Ref", "ObjectId", "S", "TypedObject", "ThreadType", "ViewType", "TableSchema", "S", "Struct", "id", "ObjectId", "name", "optional", "String", "view", "Ref", "ViewType", "threads", "Array", "ThreadType", "TableType", "TypedObject", "typename", "version", "fields"]
-}