Skip to content

The open alternative to Salesforce, designed for AI.

2.0 KB
Raw Blame
import { isDefined, isValidationRuleReservedName } from 'twenty-shared/utils';

import { SettingsValidationRuleExpressionText } from '@/validation-rules/components/SettingsValidationRuleExpressionText';
import { SettingsValidationRuleFieldChip } from '@/validation-rules/components/SettingsValidationRuleFieldChip';
import { type ValidationRuleEditorField } from '@/validation-rules/types/ValidationRuleEditorField';
import { computeValidationRuleEditorSegments } from '@/validation-rules/utils/computeValidationRuleEditorSegments';
import { getValidationRuleEditorFieldChipLabel } from '@/validation-rules/utils/getValidationRuleEditorFieldChipLabel';

type SettingsValidationRuleExampleExpressionProps = {
  expression: string;
  editorFields: ValidationRuleEditorField[];
};

export const SettingsValidationRuleExampleExpression = ({
  expression,
  editorFields,
}: SettingsValidationRuleExampleExpressionProps) => {
  const findEditorField = (path: string) => {
    return editorFields.find((editorField) => editorField.path === path);
  };

  const segments = computeValidationRuleEditorSegments({
    expression,
    isFieldPath: (path) =>
      !isValidationRuleReservedName({ name: path, isMember: false }) &&
      isDefined(findEditorField(path)),
    cursorOffset: null,
    fieldRanges: [],
  });

  return (
    <>
      {segments.map((segment, index) => {
        if (segment.type === 'text') {
          return (
            <SettingsValidationRuleExpressionText
              key={index}
              expression={segment.text}
            />
          );
        }

        const editorField = findEditorField(segment.path);

        return isDefined(editorField) ? (
          <SettingsValidationRuleFieldChip
            key={index}
            path={editorField.path}
            label={getValidationRuleEditorFieldChipLabel(editorField)}
            iconName={editorField.iconName}
          />
        ) : (
          <SettingsValidationRuleExpressionText
            key={index}
            expression={segment.path}
          />
        );
      })}
    </>
  );
};