reactjs-query-builder/build/npm/lib/components/FieldFunctionValueSrc.js

README.md

'use strict';

exports.__esModule = true;

var _select = require('antd/lib/select');

var _select2 = _interopRequireDefault(_select);

require('antd/lib/select/style/css');

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _propTypes = require('prop-types');

var _propTypes2 = _interopRequireDefault(_propTypes);

var _last = require('lodash/last');

var _last2 = _interopRequireDefault(_last);

var _keys = require('lodash/keys');

var _keys2 = _interopRequireDefault(_keys);

var _clone = require('clone');

var _clone2 = _interopRequireDefault(_clone);

var _configUtils = require('../utils/configUtils');

var _stuff = require('../utils/stuff');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Option = _select2.default.Option,
    OptGroup = _select2.default.OptGroup;

var FieldFunctionValueSrc = function FieldFunctionValueSrc(props) {
    var handleChangeValue = props.handleChangeValue,
        config = props.config,
        field = props.field,
        operator = props.operator,
        valueSelected = props.valueSelected,
        dataTypeOfParam = props.dataTypeOfParam;


    var buildSelectItems = function buildSelectItems(fields) {
        var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

        var fieldSeparator = config.settings.fieldSeparator;
        var maxLabelsLength = config.settings.maxLabelsLength || 100;
        if (!fields) return null;
        var prefix = path ? path.join(fieldSeparator) + fieldSeparator : '';

        return (0, _keys2.default)(fields).map(function (fieldKey) {
            var field = fields[fieldKey];
            var label = field.label || (0, _last2.default)(fieldKey.split(fieldSeparator));
            label = (0, _stuff.truncateString)(label, maxLabelsLength);
            if (field.type == "!struct") {
                var subpath = (path ? path : []).concat(fieldKey);
                return _react2.default.createElement(
                    OptGroup,
                    {
                        key: prefix + fieldKey,
                        label: label
                    },
                    buildSelectItems(field.subfields, subpath)
                );
            } else {
                return _react2.default.createElement(
                    Option,
                    {
                        key: prefix + fieldKey,
                        value: prefix + fieldKey
                    },
                    label
                );
            }
        });
    };

    var filterFields = function filterFields(config, fields, leftFieldFullkey, operator) {
        fields = (0, _clone2.default)(fields);
        var fieldSeparator = config.settings.fieldSeparator;
        var leftFieldConfig = (0, _configUtils.getFieldConfig)(leftFieldFullkey, config);
        var expectedType = void 0;
        var widget = (0, _configUtils.getWidgetForFieldOp)(config, leftFieldFullkey, operator, 'value');
        if (widget) {
            var widgetConfig = config.widgets[widget];
            var widgetType = widgetConfig.type;
            //expectedType = leftFieldConfig.type;
            expectedType = widgetType;
        } else {
            expectedType = leftFieldConfig.type;
        }
        function _filter(list, path) {
            for (var rightFieldKey in list) {
                var subfields = list[rightFieldKey].subfields;
                var subpath = (path ? path : []).concat(rightFieldKey);
                var rightFieldFullkey = subpath.join(fieldSeparator);
                var rightFieldConfig = (0, _configUtils.getFieldConfig)(rightFieldFullkey, config);
                if (rightFieldConfig.type == "!struct") {
                    _filter(subfields, subpath);
                } else {
                    var canUse = rightFieldConfig.type == dataTypeOfParam && rightFieldFullkey != leftFieldFullkey;
                    var fn = config.settings.canCompareFieldWithField;
                    if (fn) canUse = canUse && fn(leftFieldFullkey, leftFieldConfig, rightFieldFullkey, rightFieldConfig);
                    if (!canUse) delete list[rightFieldKey];
                }
            }
        }

        _filter(fields, []);

        return fields;
    };

    var fieldOptions = filterFields(config, config.fields, field, operator);
    var placeholder = config.settings.fieldPlaceholder;
    var buildSelectOptionItems = buildSelectItems(fieldOptions);

    return _react2.default.createElement(
        'div',
        { className: 'valuesrc--function' },
        _react2.default.createElement(
            _select2.default,
            {
                showSearch: true,
                value: valueSelected || undefined,
                style: { width: 200 },
                placeholder: placeholder,
                size: config.settings.renderSize || "small",
                onChange: handleChangeValue,
                optionFilterProp: 'children'
            },
            buildSelectOptionItems
        )
    );
};

FieldFunctionValueSrc.propsTypes = {
    handleChangeValue: _propTypes2.default.func.isRequired,
    config: _propTypes2.default.object.isRequired,
    field: _propTypes2.default.string.isRequired,
    operator: _propTypes2.default.string.isRequired,
    valueSelected: _propTypes2.default.string,
    dataTypeOfParam: _propTypes2.default.string.isRequired
};

FieldFunctionValueSrc.defaultProps = {
    valueSelected: ''
};

exports.default = FieldFunctionValueSrc;