@wix/patterns 1.422.0 → 1.424.0

package/src/state/CollectionFieldsSourceState.ts

@@ -0,0 +1,270 @@
+import { reaction } from 'mobx';
+import type { ComponentType } from 'react';
+import { addEventListener, TaskState } from '@wix/bex-core';
+import type {
+  FieldsSource,
+  CustomFieldOrigin,
+  Field,
+  WixPatternsErrorCode,
+} from '@wix/bex-core';
+import type { Column } from '../model';
+import type { ToolbarCollectionState } from './ToolbarCollectionState';
+import { buildFieldColumns, ColumnOverridesContext } from './buildFieldColumns';
+import { handleFieldsSourceLoadError } from './handleFieldsSourceLoadError';
+import {
+  buildFieldFilters,
+  registerFieldFilters,
+  type FieldFilterConfig,
+} from './buildFieldFilters';
+import type {
+  FilterElement,
+  CollectionToolbarFiltersProps,
+} from '../components/CollectionToolbarFilters';
+import type { MoreActionItemFactory } from '../components/MoreActions/MoreActionsBase';
+import {
+  CustomFieldsPanelState,
+  type FieldActionsMenuBuilder,
+} from './CustomFields/CustomFieldsPanelState';
+import type { FieldActionHandlersConfig } from '../components/FieldActions';
+import type { CustomColumnsBaseProps } from '../components/CustomColumns/CustomColumns';
+
+/** Builds the raw field-management for one field (handlers + registry metadata). */
+type FieldActionHandlersBuilder = (args: {
+  fieldId: string;
+  origin: CustomFieldOrigin;
+  location: string;
+}) => FieldActionHandlersConfig | null;
+
+/**
+ * Components the source attaches at construction time so the table chunk can
+ * render them via `source.components.X` instead of statically importing them.
+ * Each source's rendering file (dataExtensionRendering / schemaRendering) is
+ * the only place these are imported — those files are reachable only from the
+ * source's feature module, so the components ship in that chunk, not the
+ * table chunk.
+ */
+export interface FieldsSourceComponents {
+  FieldManagementModals: ComponentType<{ source: CollectionFieldsSourceState }>;
+  CustomColumns: ComponentType<CustomColumnsBaseProps>;
+  CollectionToolbarFilters: ComponentType<CollectionToolbarFiltersProps>;
+}
+
+/**
+ * The source-specific behavior a collection supplies on top of its FieldsSource
+ * (data) — column tweaks, filter behavior, the manage-fields panel, page actions,
+ * field actions, and the field-management modal states. A source builds one of
+ * these (dataExtensionRendering / schemaRendering); it is spread onto
+ * CollectionFieldsSourceState, which owns the pieces directly. The collection
+ * renders these with shared, source-neutral components.
+ */
+export interface FieldsSourceRendering {
+  /**
+   * Lets a source replace any column property the shared builder produces,
+   * including the render function for media types. Called per field.
+   */
+  columnOverrides?(field: Field, ctx: ColumnOverridesContext): Partial<Column>;
+  /** Per-source filter behavior (text operators, decimal, type icon). */
+  filterConfig: FieldFilterConfig;
+  /**
+   * Builds the source's per-field actions menu for the panel it belongs to. The
+   * spine builds the panel and passes it in; the resulting menu drives both the
+   * manage-fields panel and the customize-columns header.
+   */
+  createFieldActionsMenu: (
+    panel: CustomFieldsPanelState,
+  ) => FieldActionsMenuBuilder;
+  /**
+   * Builds the raw field-management for one field (handlers + registry metadata)
+   * for the panel it belongs to, before grouping. The header merges these with
+   * its table-intrinsic actions (sort / hide / filter). Omitted by sources with
+   * no field actions.
+   */
+  createFieldActionHandlers?: (
+    panel: CustomFieldsPanelState,
+  ) => FieldActionHandlersBuilder;
+  featuredPageActions: MoreActionItemFactory[];
+  props?: { disableDefaultPageAction?: boolean };
+  /** BI error code reported when the source's load fails. Default: 'InitCustomFieldsDataExtensionFailed'. */
+  errorCode?: WixPatternsErrorCode;
+  /** The source provides these so the table chunk renders them via DI rather
+   *  than static import. See FieldsSourceComponents. */
+  components: FieldsSourceComponents;
+}
+
+/**
+ * A collection's field source: the FieldsSource (data) plus the source's UI,
+ * held as flat members. The toolbar holds one of these rather than a specific
+ * source. It owns the load status (initTask); field and filter reads pass
+ * through to the FieldsSource's own observables.
+ */
+export class CollectionFieldsSourceState {
+  readonly fieldsSource: FieldsSource;
+  /** The field-management state (modals + per-field menu). Built here from the
+   *  source's config so every source gets the same panel. */
+  readonly customFieldsPanel: CustomFieldsPanelState;
+  readonly featuredPageActions: MoreActionItemFactory[];
+  readonly props?: { disableDefaultPageAction?: boolean };
+  readonly filterConfig: FieldFilterConfig;
+  readonly openFieldModal: (opts?: {
+    fieldId?: string;
+    origin?: CustomFieldOrigin;
+    customOrigin?: string;
+  }) => void;
+  readonly fieldActionsMenu: FieldActionsMenuBuilder;
+  readonly fieldActionHandlers?: FieldActionHandlersBuilder;
+  readonly components: FieldsSourceComponents;
+  private readonly columnOverrides?: FieldsSourceRendering['columnOverrides'];
+  private readonly toolbar: ToolbarCollectionState<any, any>;
+  private readonly errorCode: WixPatternsErrorCode;
+  private hasBuiltColumns = false;
+
+  constructor(
+    params: {
+      fieldsSource: FieldsSource;
+      toolbar: ToolbarCollectionState<any, any>;
+    } & FieldsSourceRendering,
+  ) {
+    this.fieldsSource = params.fieldsSource;
+    this.toolbar = params.toolbar;
+    this.featuredPageActions = params.featuredPageActions;
+    this.props = params.props;
+    this.filterConfig = params.filterConfig;
+    this.columnOverrides = params.columnOverrides;
+    this.components = params.components;
+    this.errorCode = params.errorCode ?? 'InitCustomFieldsDataExtensionFailed';
+
+    // The panel is generic — the source supplies only its config (the menu
+    // factory); the table's container/reportBi wire it up. The panel builds all
+    // three field-management modals (add/edit, archive, delete) itself.
+    this.customFieldsPanel = new CustomFieldsPanelState({
+      fieldsSource: params.fieldsSource,
+      container: this.toolbar.container,
+      reportBi: this.toolbar.reportBi,
+      closeSidePanel: this.toolbar.closeSidePanel,
+      createFieldActionsMenu: params.createFieldActionsMenu,
+    });
+    // Opening the add/edit modal and reading the per-field menu are the same for
+    // every source, so derive them from the panel rather than per-source.
+    this.openFieldModal = (opts) =>
+      this.customFieldsPanel.openCustomFieldModal({
+        fieldId: opts?.fieldId,
+        origin: opts?.origin ?? 'external',
+        customOrigin: opts?.customOrigin,
+      });
+    this.fieldActionsMenu = this.customFieldsPanel.fieldActionsMenu;
+    this.fieldActionHandlers = params.createFieldActionHandlers?.(
+      this.customFieldsPanel,
+    );
+  }
+
+  /**
+   * Attaches a source to a table's toolbar. Builds the wrapper once; calling it
+   * again (e.g. on re-render) is a no-op.
+   */
+  static setOnTable(
+    toolbar: ToolbarCollectionState<any, any>,
+    source: { fieldsSource: FieldsSource } & FieldsSourceRendering,
+  ) {
+    toolbar.collectionFieldsSource ??= new CollectionFieldsSourceState({
+      ...source,
+      toolbar,
+    });
+  }
+
+  readonly initTask = new TaskState();
+
+  buildFilters(): FilterElement[] {
+    return buildFieldFilters(
+      this.toolbar,
+      this.fieldsSource.filterableFields,
+      this.filterConfig,
+    );
+  }
+
+  /** Registers a filter state per filterable field on the collection query. */
+  registerFilters() {
+    registerFieldFilters(
+      this.toolbar,
+      this.fieldsSource.filterableFields,
+      this.filterConfig,
+    );
+  }
+
+  /**
+   * Builds the columns from the fields, or null while the source is still
+   * loading so existing columns are kept.
+   */
+  buildColumns(firstBuild: boolean): Column[] | null {
+    if (!this.initTask.status.isSuccess) {
+      return null;
+    }
+    return buildFieldColumns(this.fieldsSource, this.columnOverrides, {
+      firstBuild,
+    });
+  }
+
+  syncColumns() {
+    const columns = this.buildColumns(!this.hasBuiltColumns);
+    if (columns) {
+      this.toolbar.setExtendedColumns(columns);
+      this.hasBuiltColumns = true;
+    }
+  }
+
+  init() {
+    this.initTask.runOnce(() => this.fieldsSource.load());
+    this.initTask.status.promise?.catch(() => this.handleLoadError());
+
+    const disposers = [
+      // Push the columns once the source loads, and again whenever the field
+      // list changes (add/edit/delete field). The first push starts every
+      // column hidden; later pushes keep the user's selection.
+      reaction(
+        () =>
+          [this.fieldsSource.fields, this.initTask.status.isSuccess] as const,
+        () => this.syncColumns(),
+      ),
+      // Register a filter state per filterable field. filterableFields populates
+      // inside the source's load (before initTask resolves), so the collection's
+      // initial fetch still waits for these — matching the prior per-source timing.
+      reaction(
+        () => this.fieldsSource.filterableFields,
+        () => this.registerFilters(),
+        { fireImmediately: true },
+      ),
+      // Make custom-columns storage reconciliation wait until this source's
+      // columns are built, so a stored hide/show selection for source fields
+      // survives a reload. Covers any source.
+      ...(this.toolbar.customColumnsState?.events
+        ? [
+            addEventListener(
+              this.toolbar.customColumnsState.events,
+              'beforeInitialFetch',
+              () => this.initTask.status.promise?.catch(() => {}),
+            ),
+          ]
+        : []),
+    ];
+
+    return () => {
+      disposers.forEach((d) => d?.());
+    };
+  }
+
+  private handleLoadError() {
+    handleFieldsSourceLoadError({
+      container: this.toolbar.container,
+      reportBi: this.toolbar.reportBi,
+      error: this.initTask.status.error,
+      errorCode: this.errorCode,
+      reload: () => this.retryLoad(),
+    });
+  }
+
+  /** Re-runs the source load after a failure (the retry toast). */
+  private retryLoad() {
+    this.initTask.reset();
+    this.initTask.runOnce(() => this.fieldsSource.load());
+    return this.initTask.status.promise;
+  }
+}

package/src/state/CollectionPage/CollectionPageHeader.st.css.ts

@@ -5,7 +5,7 @@ import { classesRuntime, statesRuntime } from "../../stylable-esm-runtime.js";
 
 
 
-var _namespace_ = "CollectionPageHeader1867011218";
+var _namespace_ = "CollectionPageHeader3086631792";
 var _style_ = classesRuntime.bind(null, _namespace_);
 
 export var cssStates = statesRuntime.bind(null, _namespace_);
@@ -13,7 +13,7 @@ export var style = _style_;
 export var st: import("@stylable/runtime").STFunction = _style_;
 
 export var namespace = _namespace_;
-export var classes = {"root":"CollectionPageHeader1867011218__root"};
+export var classes = {"root":"CollectionPageHeader3086631792__root"};
 export var keyframes = {}; 
 export var layers = {};
 export var containers = {};

package/src/state/CollectionViewsState.ts

@@ -7,7 +7,7 @@ import {
   WixPatternsError,
 } from '@wix/bex-core';
 import { ViewsState } from './ViewsState';
-import { ViewsProps } from '../index';
+import type { ViewsProps } from '../index';
 import { action, computed, makeObservable, reaction, runInAction } from 'mobx';
 import {
   AllItemsViewProps,

package/src/state/CustomColumnsEntityPageState.ts

@@ -114,7 +114,7 @@ export class CustomColumnsEntityPageState extends CustomColumnsPanelStateBase {
     return this._showFieldTypeIcons;
   }
 
-  get collectionDataExtension() {
+  get collectionFieldsSource() {
     return null;
   }
 

package/src/state/CustomColumnsPanelStateBase.ts

@@ -9,7 +9,7 @@ import { action, computed, makeObservable, observable } from 'mobx';
 import { Column } from '../model';
 import { CustomColumnsActionName } from './CustomColumnsState';
 import type { CustomColumnsDragAndDropState } from './CustomColumnsDragAndDropState';
-import type { CollectionDataExtensionState } from '../components/DataExtension';
+import type { CollectionFieldsSourceState } from './CollectionFieldsSourceState';
 
 export interface CustomColumnsPanelStateBaseParams {
   container: WixPatternsContainer;
@@ -63,8 +63,8 @@ export abstract class CustomColumnsPanelStateBase<
 
   abstract get showFieldTypeIcons(): boolean;
 
-  abstract get collectionDataExtension():
-    | CollectionDataExtensionState<T, F>
+  abstract get collectionFieldsSource():
+    | CollectionFieldsSourceState
     | null
     | undefined;
 

package/src/state/CustomColumnsState.ts

@@ -16,11 +16,9 @@ import {
   cairoFiltersPanelUsed,
 } from '@wix/bex-core/bi';
 import type { CustomColumnsDragAndDropState } from './CustomColumnsDragAndDropState';
-import type { CollectionDataExtensionState } from '../components/DataExtension';
 import { CustomColumnsPanelStateBase } from './CustomColumnsPanelStateBase';
 
 export type { CustomColumnsDragAndDropState };
-export type { CollectionDataExtensionState };
 
 export type CustomColumnsPanelState<
   T = unknown,
@@ -503,8 +501,8 @@ export class CustomColumnsState<
     return this.table.showFieldTypeIcons;
   }
 
-  get collectionDataExtension() {
-    return this.table.collectionDataExtension;
+  get collectionFieldsSource() {
+    return this.table.collectionFieldsSource;
   }
 
   get sidePanelTransition() {

package/src/state/CustomFields/CustomFieldsPanelState.ts

@@ -2,37 +2,93 @@ import {
   ArchiveFieldModalState,
   CustomFieldModalState,
   CustomFieldOrigin,
-  DataExtensionState,
+  DeleteFieldModalState,
+  FieldsSource,
   ReportBI,
+  WixPatternsContainer,
 } from '@wix/bex-core';
 import { makeAutoObservable } from 'mobx';
+import type { FieldActionsMenuConfig } from '../../components/FieldActions';
+
+/** Builds the per-field action popover (edit / archive / delete …) for a field. */
+export type FieldActionsMenuBuilder = (args: {
+  fieldId: string;
+  origin: CustomFieldOrigin;
+  location: string;
+}) => FieldActionsMenuConfig | null;
 
 export interface CustomFieldsPanelStateParams {
   readonly reportBi: ReportBI;
   readonly closeSidePanel: () => unknown;
-  readonly dataExtension: DataExtensionState;
+  readonly fieldsSource: FieldsSource;
+  readonly container: WixPatternsContainer;
+  /**
+   * The source's per-field menu, as a factory over the panel it belongs to (its
+   * handlers call back into this panel's modals). Built once in the constructor.
+   */
+  readonly createFieldActionsMenu: (
+    panel: CustomFieldsPanelState,
+  ) => FieldActionsMenuBuilder;
 }
 
 export class CustomFieldsPanelState {
   readonly reportBi;
   readonly closeSidePanel;
-  readonly dataExtension;
+  readonly fieldsSource;
+  readonly container;
   readonly customFieldModal;
-  readonly archiveFieldModal;
+  readonly archiveFieldModal?: ArchiveFieldModalState;
+  readonly deleteFieldModal: DeleteFieldModalState;
+  /** The per-field action popover. The source supplies it; CustomFieldItem reads it. */
+  readonly fieldActionsMenu: FieldActionsMenuBuilder;
 
   constructor(params: CustomFieldsPanelStateParams) {
     this.reportBi = params.reportBi;
     this.closeSidePanel = params.closeSidePanel;
-    this.dataExtension = params.dataExtension;
-    this.archiveFieldModal = new ArchiveFieldModalState({
+    this.fieldsSource = params.fieldsSource;
+    this.container = params.container;
+
+    if (params.fieldsSource.archive) {
+      this.archiveFieldModal = new ArchiveFieldModalState({
+        reportBi: this.reportBi,
+        archiver: params.fieldsSource.archive,
+      });
+    }
+    this.customFieldModal = new CustomFieldModalState({
       reportBi: this.reportBi,
-      dataExtension: this.dataExtension,
+      fieldManagement: params.fieldsSource.fieldManagement!,
+      container: params.container,
+      fieldCount: () => params.fieldsSource.manageableFields.length,
     });
-    this.customFieldModal = new CustomFieldModalState({
+    // The delete runs through the source's own deleteField (which reports its
+    // own toast) and reconciles the archived-items list when archiving exists.
+    this.deleteFieldModal = new DeleteFieldModalState({
       reportBi: this.reportBi,
-      dataExtensionState: this.dataExtension,
+      fieldManagement: {
+        deleteField: (id, origin) =>
+          params.fieldsSource.fieldManagement!.deleteField(id, origin),
+      },
+      archive: params.fieldsSource.archive ?? {
+        items: [],
+        closePanel: () => undefined,
+      },
+    });
+    this.fieldActionsMenu = params.createFieldActionsMenu(this);
+    makeAutoObservable(this, {
+      // A function that builds (doesn't mutate) the popover — not an action. It's
+      // set once here and never reassigned, so it needn't be observable either.
+      fieldActionsMenu: false,
     });
-    makeAutoObservable(this);
+  }
+
+  get fieldManagement() {
+    return this.fieldsSource.fieldManagement;
+  }
+  get manageableFields() {
+    return this.fieldsSource.manageableFields;
+  }
+  get archive() {
+    return this.fieldsSource.archive;
   }
 
   openCustomFieldModal(params: {
@@ -41,7 +97,6 @@ export class CustomFieldsPanelState {
     customOrigin?: string;
   }) {
     const { customFieldModal } = this;
-
     const { customFieldModalBiReporter } = customFieldModal;
 
     customFieldModal.reset();
@@ -58,21 +113,17 @@ export class CustomFieldsPanelState {
     customFieldModalBiReporter.formSnapshot = null;
     customFieldModal.setDefaultPermissions();
 
-    if (this.dataExtension.userSchema) {
-      if (params.fieldId) {
-        const formValues = this.dataExtension.extractFieldValuesFromSchema(
-          params.fieldId,
-        );
-
-        if (!formValues) {
-          return;
-        }
-
-        customFieldModal.setFormValues(formValues, {
-          disablePermissionCheckboxes: true,
-        });
-        customFieldModalBiReporter.formSnapshot = formValues;
+    if (params.fieldId) {
+      const formValues = this.fieldsSource.fieldManagement?.getFieldDraft(
+        params.fieldId,
+      );
+      if (!formValues) {
+        return;
       }
+      customFieldModal.setFormValues(formValues, {
+        disablePermissionCheckboxes: true,
+      });
+      customFieldModalBiReporter.formSnapshot = formValues;
     }
 
     customFieldModal.modalState.modal.open();

package/src/state/CustomFields/CustomFieldsWidgetState.ts

@@ -22,6 +22,8 @@ import {
 
 import { CustomFieldsAllNamespacesFormState } from './CustomFieldsAllNamespacesFormState';
 import { CustomFieldsPanelState } from './CustomFieldsPanelState';
+import { dataExtensionFieldsSourceFrom } from '../../components/DataExtension/dataExtensionFieldsSource';
+import { createDataExtensionFieldActionsMenu } from '../../components/DataExtension/dataExtensionFieldActions';
 
 export interface CustomFieldsWidgetStateParams {
   readonly container: WixPatternsContainer;
@@ -98,9 +100,16 @@ export class CustomFieldsWidgetState {
     });
 
     this.customFieldsPanel = new CustomFieldsPanelState({
-      dataExtension: this.dataExtension,
+      fieldsSource: dataExtensionFieldsSourceFrom({
+        dataExtension: this.dataExtension,
+        reportBi: this.reportBi,
+      }),
+      container,
       reportBi: this.reportBi,
       closeSidePanel: this.panels.closeSidePanel,
+      createFieldActionsMenu: createDataExtensionFieldActionsMenu(
+        this.dataExtension,
+      ),
     });
 
     makeObservable(this, {

package/src/state/DropdownCollectionFilterState.ts

@@ -13,6 +13,7 @@ export interface DropdownCollectionFilterStateParams<
   resetOnClose?: boolean;
   container: WixPatternsContainer;
   toolbar: FilterToolbarState;
+  maxSelected?: number;
 }
 
 export class DropdownCollectionFilterState<
@@ -75,6 +76,7 @@ export class DropdownCollectionFilterState<
       container: params.container,
       toolbar: params.toolbar,
       filter,
+      maxSelected: params.maxSelected,
     });
 
     makeObservable(this, {

package/src/state/DropdownSelectState.ts

@@ -14,6 +14,7 @@ export interface DropdownSelectStateParams<V> {
   toolbar: FilterToolbarState;
   select?: SelectState<KeyedItem<V>>;
   filter: ArrayField<V>;
+  maxSelected?: number;
 }
 
 export class DropdownSelectState<V> {
@@ -21,6 +22,7 @@ export class DropdownSelectState<V> {
   readonly toolbar;
   readonly select: SelectState<KeyedItem<V>>;
   readonly _filter: DropdownSelectStateParams<V>['filter'];
+  readonly maxSelected: DropdownSelectStateParams<V>['maxSelected'];
 
   readonly dropdown = new ToggleState();
 
@@ -35,12 +37,14 @@ export class DropdownSelectState<V> {
         keyGetter: (value) => value.key,
       });
     this._filter = params.filter;
+    this.maxSelected = params.maxSelected;
 
     makeObservable(this, {
       filterKeyedItems: computed,
       filterKeyedItemsMap: computed,
       finalFilterKeyedItems: computed,
       finalFilterKeyedItemsMap: computed,
+      reachedMax: computed,
       selectedItems: computed({
         keepAlive: true,
       }),
@@ -120,8 +124,24 @@ export class DropdownSelectState<V> {
     return select.selectedValues.map(({ item }) => item);
   }
 
+  get reachedMax() {
+    const { maxSelected, select } = this;
+    return maxSelected != null && select.selectedCount >= maxSelected;
+  }
+
+  canToggle(key: string) {
+    if (!this.reachedMax) {
+      return true;
+    }
+    // at the cap: only existing keys, so they stay deselectable
+    return this.select.selectedKeys.includes(key);
+  }
+
   set(item: KeyedItem<V>) {
     const { select } = this;
+    if (!this.canToggle(item.key)) {
+      return;
+    }
     select.set(item);
     this.refreshIfChanged({ actionType: 'add', clickedValueKey: item.key });
   }

package/src/state/EditableTable/CellValueState.ts

@@ -1,4 +1,4 @@
-import { action, makeObservable, observable } from 'mobx';
+import { action, computed, makeObservable, observable } from 'mobx';
 import type { CellType, Cell, ValidationResult } from './types';
 import type { FiltersMap } from '@wix/bex-core';
 import type { EditableTableState } from './EditableTableState';
@@ -18,7 +18,6 @@ export class CellValueState<T, F extends FiltersMap> {
 
   private readonly _parent: EditableTableState<T, F>;
   private readonly _extraCellTypes: Map<string, CellType>;
-  private _cellTypeMap: Map<string, CellType> = builtInCellTypeMap;
 
   constructor(
     parent: EditableTableState<T, F>,
@@ -29,6 +28,7 @@ export class CellValueState<T, F extends FiltersMap> {
 
     makeObservable(this, {
       _pendingCells: observable,
+      _cellTypeMap: computed,
       clearCells: action,
       toggleCell: action,
       commitHandler: action,
@@ -37,9 +37,12 @@ export class CellValueState<T, F extends FiltersMap> {
     });
   }
 
-  _buildCellTypeMap() {
+  // Cell-type config per column id, from the merged columns (consumer columns
+  // plus the columns the wired source adds). A computed so source columns that
+  // load after init still get their cell types registered, without a rebuild.
+  get _cellTypeMap(): Map<string, CellType> {
     const map = new Map<string, CellType>();
-    for (const col of this._parent._allColumns) {
+    for (const col of this._parent.allColumns) {
       if (
         col.cellType === 'custom' &&
         col.typeConfig &&
@@ -59,7 +62,7 @@ export class CellValueState<T, F extends FiltersMap> {
         );
       }
     }
-    this._cellTypeMap = map;
+    return map;
   }
 
   resolveCellTypeByColumnId(columnId: string): CellType {
@@ -258,6 +261,7 @@ export class CellValueState<T, F extends FiltersMap> {
         value,
         column.validation,
         resolved.validate,
+        this._parent.collection?.translate,
       );
       const pendingKey = this._pendingCellKey(rowKey, columnId);
 
@@ -290,6 +294,7 @@ export class CellValueState<T, F extends FiltersMap> {
       value,
       column.validation,
       resolved.validate,
+      this._parent.collection?.translate,
     );
     const pendingKey = this._pendingCellKey(rowKey, columnId);