Custom operator with settings/options doesn’t work

[tkapitonova]

Hi!

Is your feature request related to a problem? Please describe.
I've created my own custom operator - bitwise operator AND (implementation based on proximity operator)

Definition in config.operators

bitwise_and: {
    label: "&",
    cardinality: 1,
    labelForFormat: '&',
    formatOp: (field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) => {
        const operator = operatorOptions.get("operator");
        const value = operatorOptions.get("value");
        return `${field}&${values}${operator}${value}`;
    },
    sqlFormatOp: (field, op, values, valueSrc, valueType, opDef, operatorOptions) => {
        const operator = operatorOptions.get("operator");
        const value = operatorOptions.get("value");
        return `${field}&${values}${operator}${value}`;
    },
    mongoFormatOp: undefined,
    jsonLogic: "&",
    options: {
        factory: (props) => <BitwiseOperator {...props} />,
        default: {
            operator: " equal",
            value: ""
        }
    }
}

Settings for custom operator

import React from "react";

export default function BitwiseOperator(props) {
    const {config, options, default: defaultProps} = props;

    const {widgets} = config;
    const Select = widgets.select.factory;
    const Number = widgets.number.factory;

    const defaultOperator = defaultProps ? defaultProps.operator : "equal";
    const defaultValue = defaultProps ? defaultProps.value : undefined;

    const selectedOperator = options ? options.get("operator", defaultOperator): defaultOperator;
    const selectedValue = options ? options.get("value", defaultValue) : defaultValue;


    const operatorValues = [
        {
            title: "=",
            value: "equal"
        },
        {
            title: "!=",
            value: "not_equal"
        }
    ]

    const handleChangeOperator = (value) => {
        props.setOption("operator", value);
    }

    const handleChangeValue = (value) => {
        props.setOption("value", parseInt(value));
    }

    return (
            <div className="p-formgroup-inline">
                <Select
                    config={config}
                    value={selectedOperator}
                    listValues={operatorValues}
                    setValue={handleChangeOperator}
                    placeholder={"Enter operator 2"}
                    className="p-mr-2 p-d-inline"
                />
                &nbsp;
                <Number
                    key="bitwise_value"
                    config={config}
                    field={""}
                    value={selectedValue}
                    placeholder={"Enter value"}
                    setValue={handleChangeValue}
                    className="p-d-inline"
                />
            </div>
        );
}

if in config.types i set defaultOperator different from my custom operator,
for example: defaultOperator: "equal" then when user changes operator from default to my custom operator
props.optios returns null (props.optios=null) instead of properties (operator and value).

Describe the solution you'd like
As far as i understand such behaviour occures from flag canReuseValue in method setOperator (modules/stores/tree.js).
During Flag evaluation in method getNewValueForFieldOp (modules/utils/validation.js) additional properties of new operator aren't being taken into account.

For proximity operator described issue is not applicable because there is hard coded check for this operator:
if (currentOperator != newOperator && [currentOperator, newOperator].includes("proximity")) canReuseValue = false;

Is it possible to somehoww improve logic behind canReuseValue flag (to account custom operators properties) or am i doing something wrong?

Describe alternatives you've considered
At least for now there is a workaround: you can set config.settings.clearValueOnChangeOp=true, but it would be great if another way existed, because there are some cases when i dont want to clear filed value

Please let me know your thoughts.

Best regards.