@dxos/react-ui-table 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/dist/types/src/types/table.d.ts

@@ -1,56 +0,0 @@
-import { Schema } from 'effect';
-import { Type } from '@dxos/echo';
-import { Expando } from '@dxos/echo-schema';
-export declare const TableSchema: Schema.Struct<{
-    id: import("@dxos/keys").ObjectIdClass;
-    name: Schema.optional<typeof Schema.String>;
-    view: Schema.optional<import("@dxos/echo-schema").Ref$<import("@dxos/echo-schema").TypedObjectFields<{
-        name: Schema.SchemaClass<string, string, never>;
-        query: Schema.Schema<import("@dxos/echo-schema").QueryType, import("@dxos/echo-schema").QueryType, never>;
-        schema: Schema.optional<Schema.Schema<Type.JsonSchema, Type.JsonSchema, never>>;
-        fields: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
-            id: typeof Schema.String;
-            path: Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>;
-            visible: Schema.optional<typeof Schema.Boolean>;
-            referencePath: Schema.optional<Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>>;
-            size: Schema.optional<typeof Schema.Number>;
-        }>>>>;
-        hiddenFields: Schema.optional<Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
-            id: typeof Schema.String;
-            path: Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>;
-            visible: Schema.optional<typeof Schema.Boolean>;
-            referencePath: Schema.optional<Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>>;
-            size: Schema.optional<typeof Schema.Number>;
-        }>>>>>;
-        metadata: Schema.optional<Schema.mutable<Schema.Record$<typeof Schema.String, typeof Schema.Any>>>;
-    }, import("@dxos/echo-schema").TypedObjectOptions>>>;
-    threads: Schema.optional<Schema.Array$<import("@dxos/echo-schema").Ref$<Expando>>>;
-}>;
-export declare const TableType: Type.obj<Schema.Struct<{
-    id: import("@dxos/keys").ObjectIdClass;
-    name: Schema.optional<typeof Schema.String>;
-    view: Schema.optional<import("@dxos/echo-schema").Ref$<import("@dxos/echo-schema").TypedObjectFields<{
-        name: Schema.SchemaClass<string, string, never>;
-        query: Schema.Schema<import("@dxos/echo-schema").QueryType, import("@dxos/echo-schema").QueryType, never>;
-        schema: Schema.optional<Schema.Schema<Type.JsonSchema, Type.JsonSchema, never>>;
-        fields: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
-            id: typeof Schema.String;
-            path: Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>;
-            visible: Schema.optional<typeof Schema.Boolean>;
-            referencePath: Schema.optional<Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>>;
-            size: Schema.optional<typeof Schema.Number>;
-        }>>>>;
-        hiddenFields: Schema.optional<Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
-            id: typeof Schema.String;
-            path: Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>;
-            visible: Schema.optional<typeof Schema.Boolean>;
-            referencePath: Schema.optional<Schema.Schema<import("@dxos/effect").JsonPath, import("@dxos/effect").JsonPath, never>>;
-            size: Schema.optional<typeof Schema.Number>;
-        }>>>>>;
-        metadata: Schema.optional<Schema.mutable<Schema.Record$<typeof Schema.String, typeof Schema.Any>>>;
-    }, import("@dxos/echo-schema").TypedObjectOptions>>>;
-    threads: Schema.optional<Schema.Array$<import("@dxos/echo-schema").Ref$<Expando>>>;
-}>>;
-export interface TableType extends Schema.Schema.Type<typeof TableType> {
-}
-//# sourceMappingURL=table.d.ts.map

package/dist/types/src/types/table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/types/table.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EAAiB,OAAO,EAAmB,MAAM,mBAAmB,CAAC;AAG5E,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;EAMc,CAAC;AAGvC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;GAKrB,CAAC;AACF,MAAM,WAAW,SAAU,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC;CAAG"}

package/dist/types/src/util/table.d.ts

@@ -1,14 +0,0 @@
-import { Schema } from 'effect';
-import { type Client } from '@dxos/react-client';
-import { type Space } from '@dxos/react-client/echo';
-import { type TableType } from '../types';
-type InitialiseTableProps = {
-    client: Client;
-    space: Space;
-    table: TableType;
-    typename?: string;
-    initialRow?: boolean;
-};
-export declare const initializeTable: ({ client, space, table, typename, initialRow, }: InitialiseTableProps) => Promise<Schema.Schema.AnyNoContext>;
-export {};
-//# sourceMappingURL=table.d.ts.map

package/dist/types/src/util/table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/util/table.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAYhC,OAAO,EAAE,KAAK,MAAM,EAAa,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAQ,KAAK,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAG3D,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAG1C,KAAK,oBAAoB,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,iDAMnC,oBAAoB,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CA0C3D,CAAC"}

package/src/components/Table/CreateRefPanel.tsx

@@ -1,84 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema } from 'effect';
-import React, { useCallback, useMemo } from 'react';
-
-import { live } from '@dxos/react-client/echo';
-import { Popover } from '@dxos/react-ui';
-import { Form } from '@dxos/react-ui-form';
-import { type GridScopedProps, useGridContext } from '@dxos/react-ui-grid';
-
-import { type TableModel, type ModalController } from '../../model';
-
-export type CreateRefPanelProps = { model?: TableModel; modals: ModalController };
-
-// TODO(burdon): Factor out Space dependency (to plugin?)
-export const CreateRefPanel = ({ model, modals, __gridScope }: GridScopedProps<CreateRefPanelProps>) => {
-  const { id: gridId } = useGridContext('TableCellEditor', __gridScope);
-  const space = model?.space;
-  const state = modals.state.value;
-
-  const schema = useMemo<Schema.Schema<any> | undefined>(() => {
-    if (!space || state?.type !== 'createRefPanel') {
-      return;
-    }
-
-    const [schema] = space.db.schemaRegistry.query({ typename: state.typename }).runSync();
-    if (schema) {
-      const omit = Schema.omit<any, any, ['id']>('id');
-      return omit(schema);
-    }
-  }, [space, state]);
-
-  const handleSave = useCallback(
-    (values: any) => {
-      if (!model || !space || state?.type !== 'createRefPanel') {
-        return;
-      }
-
-      const [schema] = space.db.schemaRegistry.query({ typename: state.typename }).runSync();
-      if (schema) {
-        const obj = space.db.add(live(schema, values));
-        state.onCreate?.(obj);
-      }
-      void modals.close();
-    },
-    [modals, space, state],
-  );
-
-  const handleCancel = useCallback(() => {
-    if (model) {
-      modals.close();
-    }
-  }, [modals]);
-
-  if (!model?.view || !model.projection) {
-    return null;
-  }
-
-  return (
-    <Popover.Root
-      modal={false}
-      open={state?.type === 'createRefPanel' && !!schema}
-      onOpenChange={(nextOpen) => {
-        if (model && !nextOpen) {
-          return modals.close();
-        }
-      }}
-    >
-      <Popover.VirtualTrigger virtualRef={modals.trigger} />
-      <Popover.Portal>
-        <Popover.Content classNames='md:is-64' data-grid={gridId}>
-          <Popover.Viewport>
-            {state?.type === 'createRefPanel' && schema && (
-              <Form schema={schema} values={state.initialValues ?? {}} onSave={handleSave} onCancel={handleCancel} />
-            )}
-          </Popover.Viewport>
-          <Popover.Arrow />
-        </Popover.Content>
-      </Popover.Portal>
-    </Popover.Root>
-  );
-};

package/src/components/Table/relations.stories.tsx

@@ -1,123 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import '@dxos-theme';
-
-import { type StoryObj, type Meta } from '@storybook/react-vite';
-import { SchemaAST } from 'effect';
-import React, { useEffect, useMemo } from 'react';
-
-import { Obj, Ref, type Type } from '@dxos/echo';
-import { getSchemaTypename, toJsonSchema } from '@dxos/echo-schema';
-import { getAnnotation } from '@dxos/effect';
-import { invariant } from '@dxos/invariant';
-import { faker } from '@dxos/random';
-import { useClient } from '@dxos/react-client';
-import { useClientProvider, withClientProvider } from '@dxos/react-client/testing';
-import { DataType, createView, ViewProjection, ViewType } from '@dxos/schema';
-import { createAsyncGenerator, type ValueGenerator } from '@dxos/schema/testing';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
-
-import { Table } from './Table';
-import { useTableModel } from '../../hooks';
-import { type TableFeatures, TablePresentation, type TableRow } from '../../model';
-import { translations } from '../../translations';
-import { TableType } from '../../types';
-
-faker.seed(1);
-const generator: ValueGenerator = faker as any;
-
-// TODO(burdon): Many-to-many relations.
-// TODO(burdon): Mutable and immutable views.
-// TODO(burdon): Reconcile schemas types and utils (see API PR).
-// TODO(burdon): Base type for T (with id); see ECHO API PR?
-const useTestModel = <S extends Type.Obj.Any>(schema: S, count: number) => {
-  const { space } = useClientProvider();
-
-  const jsonSchema = useMemo(() => toJsonSchema(schema), [schema]);
-  const table = useMemo(() => {
-    if (!space) {
-      return undefined;
-    }
-    const typename = getSchemaTypename(schema);
-    invariant(typename);
-    const name = getAnnotation<string>(SchemaAST.TitleAnnotationId)(schema.ast) ?? typename;
-    const view = createView({ name, typename, jsonSchema });
-    return space.db.add(Obj.make(TableType, { view: Ref.make(view) }));
-  }, [schema, space, jsonSchema]);
-
-  const projection = useMemo(() => {
-    if (!table?.view?.target) {
-      return undefined;
-    }
-
-    // TODO(burdon): Just pass in view? Reuse same jsonSchema instance? View determines if mutable, etc.
-    return new ViewProjection(jsonSchema, table.view.target);
-  }, [jsonSchema, table]);
-
-  const features = useMemo<TableFeatures>(
-    () => ({ schemaEditable: false, dataEditable: true, selection: { enabled: false } }),
-    [],
-  );
-
-  const model = useTableModel<TableRow>({ table, projection, rows: [], features });
-  useEffect(() => {
-    if (!model || !space) {
-      return;
-    }
-
-    const objectGenerator = createAsyncGenerator(generator, schema, { db: space?.db, force: true });
-    void objectGenerator.createObjects(count).then((objects) => {
-      model.setRows(objects);
-    });
-  }, [model, space]);
-
-  const presentation = useMemo(() => {
-    if (!model) {
-      return;
-    }
-
-    return new TablePresentation(model);
-  }, [model]);
-
-  return { model, presentation };
-};
-
-const DefaultStory = () => {
-  const client = useClient();
-  const { model: orgModel, presentation: orgPresentation } = useTestModel(DataType.Organization, 50);
-  const { model: contactModel, presentation: contactPresentation } = useTestModel(DataType.Person, 50);
-
-  return (
-    <div className='is-full bs-full grid grid-cols-2 divide-x divide-separator'>
-      <Table.Root>
-        <Table.Main model={orgModel} presentation={orgPresentation} client={client} ignoreAttention />
-      </Table.Root>
-      <Table.Root>
-        <Table.Main model={contactModel} presentation={contactPresentation} client={client} ignoreAttention />
-      </Table.Root>
-    </div>
-  );
-};
-
-const meta: Meta<typeof DefaultStory> = {
-  title: 'ui/react-ui-table/relations',
-  render: DefaultStory,
-  parameters: { translations, controls: { disable: true } },
-  decorators: [
-    withClientProvider({
-      types: [TableType, ViewType, DataType.Organization, DataType.Person],
-      createIdentity: true,
-      createSpace: true,
-    }),
-    withTheme,
-    withLayout({ fullscreen: true }),
-  ],
-};
-
-export default meta;
-
-type Story = StoryObj<typeof DefaultStory>;
-
-export const Default: Story = {};

package/src/components/TableCellEditor/extension.ts

@@ -1,61 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import {
-  autocompletion,
-  pickedCompletion,
-  type CompletionContext,
-  type CompletionResult,
-} from '@codemirror/autocomplete';
-import { type Extension } from '@codemirror/state';
-import { EditorView } from '@codemirror/view';
-
-export type CompletionOptions = {
-  debug?: boolean;
-  onQuery: (text: string) => Promise<CompletionResult['options']>;
-  onMatch: (data: any) => void;
-};
-
-/**
- * Autocomplete Codemirror extension.
- * https://codemirror.net/docs/ref/#autocomplete.autocompletion
- */
-export const completion = ({ debug, onQuery, onMatch }: CompletionOptions): Extension => {
-  return [
-    EditorView.theme({
-      '.cm-completionDialog': {
-        width: 'var(--dx-gridCellWidth)',
-      },
-    }),
-
-    autocompletion({
-      icons: false,
-      activateOnTyping: true,
-      closeOnBlur: !debug,
-      override: [
-        async (context: CompletionContext): Promise<CompletionResult> => {
-          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 completion = tr.annotation(pickedCompletion);
-        if (completion) {
-          onMatch((completion as any).data);
-        }
-      });
-    }),
-  ];
-};

package/src/components/TableToolbar/TableToolbar.tsx

@@ -1,102 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Rx } from '@effect-rx/rx-react';
-import React, { useMemo } from 'react';
-
-import { live } from '@dxos/live-object';
-import { type ThemedClassName } from '@dxos/react-ui';
-import {
-  type ActionGraphEdges,
-  type ActionGraphNodes,
-  type ActionGraphProps,
-  createGapSeparator,
-  createMenuAction,
-  type MenuAction,
-  MenuProvider,
-  ToolbarMenu,
-  useMenuActions,
-} from '@dxos/react-ui-menu';
-import { rxFromSignal } from '@dxos/react-ui-menu';
-
-import { translationKey } from '../../translations';
-
-export type TableToolbarActionProperties = { type: TableToolbarActionType };
-
-export type TableToolbarAction = MenuAction<TableToolbarActionProperties>;
-
-export type TableToolbarActionType = 'add-row' | 'comment' | 'save-view';
-
-type TableToolbarState = Partial<{ viewDirty: boolean }>;
-
-export type TableToolbarProps = ThemedClassName<
-  TableToolbarState & {
-    onAdd: () => void;
-    onSave: () => void;
-    attendableId?: string;
-    customActions?: Rx.Rx<ActionGraphProps>;
-  }
->;
-
-const createTableToolbarActions = ({
-  state,
-  onAdd,
-  onSave,
-  customActions,
-}: {
-  state: TableToolbarState;
-  onAdd: () => void;
-  onSave: () => void;
-  customActions?: Rx.Rx<ActionGraphProps>;
-}) =>
-  Rx.make((get) => {
-    const add = createMenuAction<TableToolbarActionProperties>('add-row', onAdd, {
-      type: 'add-row' as const,
-      icon: 'ph--plus--regular',
-      label: ['add row', { ns: translationKey }],
-      testId: 'table.toolbar.add-row',
-    });
-    const save = createMenuAction<TableToolbarActionProperties>('save-view', onSave, {
-      type: 'save-view' as const,
-      icon: 'ph--floppy-disk--regular',
-      label: ['save view label', { ns: translationKey }],
-      testId: 'table.toolbar.save-view',
-      iconOnly: false,
-      hidden: get(rxFromSignal(() => !state.viewDirty)),
-    });
-    const gap = createGapSeparator();
-    const nodes: ActionGraphNodes = [add, save, ...gap.nodes];
-    const edges: ActionGraphEdges = nodes.map(({ id: target }) => ({ source: 'root', target }));
-    if (customActions) {
-      const custom = get(customActions);
-      nodes.push(...custom.nodes);
-      edges.push(...custom.edges);
-    }
-    return {
-      nodes,
-      edges,
-    };
-  });
-
-export const TableToolbar = ({
-  classNames,
-  viewDirty,
-  attendableId,
-  onAdd,
-  onSave,
-  customActions,
-}: TableToolbarProps) => {
-  const state = useMemo(() => live<TableToolbarState>({ viewDirty }), []);
-  const actionsCreator = useMemo(
-    () => createTableToolbarActions({ state, onAdd, onSave, customActions }),
-    [state, onAdd, onSave, customActions],
-  );
-  const menu = useMenuActions(actionsCreator);
-
-  return (
-    <MenuProvider {...menu} attendableId={attendableId}>
-      <ToolbarMenu classNames={classNames} />
-    </MenuProvider>
-  );
-};

package/src/components/TableToolbar/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './TableToolbar';

package/src/model/table-sorting.ts

@@ -1,216 +0,0 @@
-//
-// 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 TableRow } 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 TableRow> {
-  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 });
-  }
-}