fix: default conditional filter to field mode (#2198)

* fix: default conditional filter to field mode

* test: align field reference operator expectations

Author: nichenqin

packages/core/src/models/view/filter/field-reference.spec.ts

@@ -6,16 +6,26 @@ import {
   isFieldReferenceOperatorSupported,
 } from './field-reference';
 import {
+  contains,
+  doesNotContain,
+  hasAllOf,
+  hasAnyOf,
+  hasNoneOf,
   is,
   isAfter,
+  isAnyOf,
   isBefore,
+  isExactly,
   isGreater,
   isGreaterEqual,
   isLess,
   isLessEqual,
   isNot,
+  isNotExactly,
+  isNoneOf,
   isOnOrAfter,
   isOnOrBefore,
+  isWithIn,
 } from './operator';
 
 describe('field reference operator helpers', () => {
@@ -48,8 +58,13 @@ describe('field reference operator helpers', () => {
     type: FieldType.CreatedBy,
   } as const;
 
-  it('returns equality operators for string fields', () => {
-    expect(getFieldReferenceSupportedOperators(stringField)).toEqual([is.value, isNot.value]);
+  it('returns text operators for string fields', () => {
+    expect(getFieldReferenceSupportedOperators(stringField)).toEqual([
+      is.value,
+      isNot.value,
+      contains.value,
+      doesNotContain.value,
+    ]);
   });
 
   it('returns comparison operators for number fields', () => {
@@ -67,21 +82,30 @@ describe('field reference operator helpers', () => {
     expect(getFieldReferenceSupportedOperators(dateField)).toEqual([
       is.value,
       isNot.value,
+      isWithIn.value,
       isBefore.value,
       isAfter.value,
       isOnOrBefore.value,
       isOnOrAfter.value,
     ]);
   });
 
-  it('excludes operators for multi-value user field', () => {
-    expect(getFieldReferenceSupportedOperators(multiUserField)).toEqual([]);
+  it('returns collection operators for multi-value user field', () => {
+    expect(getFieldReferenceSupportedOperators(multiUserField)).toEqual([
+      hasAnyOf.value,
+      hasAllOf.value,
+      isExactly.value,
+      hasNoneOf.value,
+      isNotExactly.value,
+    ]);
   });
 
   it('checks operator support', () => {
     expect(isFieldReferenceOperatorSupported(dateField, isBefore.value)).toBe(true);
     expect(isFieldReferenceOperatorSupported(stringField, isAfter.value)).toBe(false);
-    expect(isFieldReferenceOperatorSupported(multiUserField, is.value)).toBe(false);
+    expect(isFieldReferenceOperatorSupported(multiUserField, hasAnyOf.value)).toBe(true);
+    expect(isFieldReferenceOperatorSupported(stringField, isAnyOf.value)).toBe(false);
+    expect(isFieldReferenceOperatorSupported(stringField, isNoneOf.value)).toBe(false);
     expect(isFieldReferenceOperatorSupported(numberField, null)).toBe(false);
   });
 

packages/core/src/models/view/filter/field-reference.ts

@@ -1,19 +1,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { CellValueType, FieldType } from '../../field/constant';
 import type { IOperator } from './operator';
-import {
-  getValidFilterOperators,
-  is,
-  isAfter,
-  isBefore,
-  isGreater,
-  isGreaterEqual,
-  isLess,
-  isLessEqual,
-  isNot,
-  isOnOrAfter,
-  isOnOrBefore,
-} from './operator';
+import { getValidFilterOperators, isEmpty, isNotEmpty } from './operator';
 
 type FieldShape = {
   cellValueType: CellValueType;
@@ -70,32 +58,11 @@ export function isFieldReferenceComparable(field: FieldShape, reference: FieldSh
   return getFieldReferenceComparisonKind(field) === getFieldReferenceComparisonKind(reference);
 }
 
-const FIELD_REFERENCE_OPERATOR_MAP: Record<CellValueType, ReadonlySet<IOperator>> = {
-  [CellValueType.String]: new Set<IOperator>([is.value, isNot.value]),
-  [CellValueType.Number]: new Set<IOperator>([
-    is.value,
-    isNot.value,
-    isGreater.value,
-    isGreaterEqual.value,
-    isLess.value,
-    isLessEqual.value,
-  ]),
-  [CellValueType.Boolean]: new Set<IOperator>([is.value, isNot.value]),
-  [CellValueType.DateTime]: new Set<IOperator>([
-    is.value,
-    isNot.value,
-    isBefore.value,
-    isAfter.value,
-    isOnOrBefore.value,
-    isOnOrAfter.value,
-  ]),
-};
+const FIELD_REFERENCE_UNSUPPORTED_OPERATORS = new Set<IOperator>([isEmpty.value, isNotEmpty.value]);
 
 export function getFieldReferenceSupportedOperators(field: FieldShape): IOperator[] {
   const validOperators = getValidFilterOperators(field);
-  const supported = FIELD_REFERENCE_OPERATOR_MAP[field.cellValueType] ?? new Set<IOperator>();
-
-  return validOperators.filter((op) => supported.has(op));
+  return validOperators.filter((op) => !FIELD_REFERENCE_UNSUPPORTED_OPERATORS.has(op));
 }
 
 export function isFieldReferenceOperatorSupported(
@@ -105,6 +72,10 @@ export function isFieldReferenceOperatorSupported(
   if (!operator) {
     return false;
   }
-  const supported = getFieldReferenceSupportedOperators(field);
-  return supported.includes(operator);
+  if (FIELD_REFERENCE_UNSUPPORTED_OPERATORS.has(operator)) {
+    return false;
+  }
+
+  const validOperators = getValidFilterOperators(field);
+  return validOperators.includes(operator);
 }

packages/sdk/src/components/filter/view-filter/custom-component/BaseFieldValue.tsx

@@ -18,7 +18,7 @@ import {
   TooltipTrigger,
   cn,
 } from '@teable/ui-lib';
-import { cloneElement, useCallback, useEffect, useMemo, useState } from 'react';
+import { cloneElement, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import type { ReactElement } from 'react';
 import { useTranslation } from '../../../../context/app/i18n';
 import type { DateField, IFieldInstance } from '../../../../model';
@@ -103,6 +103,47 @@ const ConditionalRollupValue = (props: IConditionalRollupValueProps) => {
   );
 
   const toggleDisabled = !operatorSupportsReferences || !referenceFields.length;
+  const lastDefaultKeyRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    if (!referenceFields.length || !field || !operator || !operatorSupportsReferences) {
+      return;
+    }
+
+    const currentKey = `${field.id}:${operator}`;
+    if (value !== null && value !== undefined) {
+      lastDefaultKeyRef.current = currentKey;
+      return;
+    }
+
+    if (lastDefaultKeyRef.current === currentKey) {
+      return;
+    }
+
+    const comparableField = referenceFields.find(
+      (candidate) => !isReferenceFieldDisabled(candidate)
+    );
+    const targetField = comparableField ?? referenceFields[0];
+    if (!targetField) {
+      return;
+    }
+
+    lastDefaultKeyRef.current = currentKey;
+    onSelect({
+      type: 'field',
+      fieldId: targetField.id,
+      tableId: targetField.tableId ?? referenceTableId,
+    } satisfies IFieldReferenceValue);
+  }, [
+    field,
+    isReferenceFieldDisabled,
+    onSelect,
+    operator,
+    operatorSupportsReferences,
+    referenceFields,
+    referenceTableId,
+    value,
+  ]);
 
   const handleToggle = () => {
     if (toggleDisabled) {