@evergis/react 2.0.172 → 2.0.173

package/dist/react.cjs.development.js

@@ -33,6 +33,7 @@ var Label = require('@evergis/sgis/es/features/Label');
 var Control = require('@evergis/sgis/es/controls/Control');
 var PolyEditor = require('@evergis/sgis/es/controls/PolyEditor');
 var get = _interopDefault(require('lodash/get'));
+var lodash = require('lodash');
 var ReactDOM = _interopDefault(require('react-dom'));
 var _Symbol = require('@evergis/sgis/es/symbols/Symbol');
 var Poly$1 = require('@evergis/sgis/es/features/Poly');
@@ -837,6 +838,59 @@ const isPolygonLabelSymbol = /*#__PURE__*/symbolTypeGuard('polygonLabelSymbol');
 const isPolylineLabelSymbol = /*#__PURE__*/symbolTypeGuard('polylineLabelSymbol');
 const isLabelSymbol = symbol => Boolean(symbol && (isPointLabelSymbol(symbol) || isPolygonLabelSymbol(symbol) || isPolylineLabelSymbol(symbol)));
 
+const _excluded = ["ignoreLabel", "label", "symbol", "raster", "children"];
+const createCompositeSymbol = childSymbols => ({
+  type: 'compositeSymbol',
+  childSymbols
+});
+const getChildSymbols = symbol => {
+  if (!symbol || !isCompositeSymbol(symbol)) return [];
+  return symbol.childSymbols || [];
+};
+const extractSymbol = symbol => {
+  const childSymbols = getChildSymbols(symbol);
+  return {
+    // @ts-ignore
+    symbol: childSymbols.find(isSimpleSymbol),
+    label: childSymbols.find(isLabelSymbol) || null,
+    raster: childSymbols.find(isRasterSymbol) || null
+  };
+};
+const extractStyle = style => {
+  // @ts-ignore
+  if (isCompositeSymbol(style.symbol)) {
+    return _extends({}, style, extractSymbol(style.symbol), {
+      // @ts-ignore
+      children: style.children && style.children.map(extractStyle)
+    });
+  } // NOTE: for cases when style is exist style object should have same reference for all extractStyle calls
+
+
+  return style || {};
+};
+const packStyle = style => {
+  const {
+    ignoreLabel,
+    label,
+    symbol,
+    raster,
+    children
+  } = style,
+        styleDc = _objectWithoutPropertiesLoose(style, _excluded);
+
+  const childSymbols = [!ignoreLabel && label, raster].filter(Boolean);
+  return _extends({}, styleDc, {
+    symbol: childSymbols.length ? // @ts-ignore
+    createCompositeSymbol([symbol, ...childSymbols]) : symbol,
+    // @ts-ignore
+    children: children ? // @ts-ignore
+    children.map(childStyle => packStyle(_extends({}, childStyle, {
+      ignoreLabel,
+      label
+    }))) : children
+  });
+};
+
 const isPointSymbol = /*#__PURE__*/symbolTypeGuard('circlePointSymbol');
 const isSquareSymbol = /*#__PURE__*/symbolTypeGuard('squarePointSymbol');
 const isMaskedImageSymbol = /*#__PURE__*/symbolTypeGuard('maskedImagePointSymbol');
@@ -855,6 +909,20 @@ const isScalablePolylineSymbol = symbol => symbol.beginning !== null && symbol.e
 const isSimpleSymbol = symbol => Boolean(symbol && !isLabelSymbol(symbol) && !isCompositeSymbol(symbol) && !isRasterSymbol(symbol));
 const isH3GridSymbol = /*#__PURE__*/symbolTypeGuard("h3grid");
 const isSvgPointSymbol = /*#__PURE__*/symbolTypeGuard("svgPointSymbol");
+const isClusterSymbol = /*#__PURE__*/symbolTypeGuard("cluster");
+const isClusterFillColor = (symbol, parameter) => {
+  return isClusterSymbol(symbol) && parameter === "fillColor";
+};
+const getExtractedSymbol = function getExtractedSymbol(symbol, extractCluster) {
+  var _extractSymbol;
+
+  if (extractCluster === void 0) {
+    extractCluster = false;
+  }
+
+  const extracted = isCompositeSymbol(symbol) ? (_extractSymbol = extractSymbol(symbol)) == null ? void 0 : _extractSymbol.symbol : symbol;
+  return extractCluster && isClusterSymbol(extracted) ? extracted.singleObjectSymbol : extracted;
+};
 
 const isHatchBrush = /*#__PURE__*/symbolTypeGuard('hatch');
 const isPatternBrush = /*#__PURE__*/symbolTypeGuard('pattern');
@@ -1138,59 +1206,6 @@ const mergeAttributes = (attributes1, attributes2) => {
   }) || {}));
 };
 
-const _excluded = ["ignoreLabel", "label", "symbol", "raster", "children"];
-const createCompositeSymbol = childSymbols => ({
-  type: 'compositeSymbol',
-  childSymbols
-});
-const getChildSymbols = symbol => {
-  if (!symbol || !isCompositeSymbol(symbol)) return [];
-  return symbol.childSymbols || [];
-};
-const extractSymbol = symbol => {
-  const childSymbols = getChildSymbols(symbol);
-  return {
-    // @ts-ignore
-    symbol: childSymbols.find(isSimpleSymbol),
-    label: childSymbols.find(isLabelSymbol) || null,
-    raster: childSymbols.find(isRasterSymbol) || null
-  };
-};
-const extractStyle = style => {
-  // @ts-ignore
-  if (isCompositeSymbol(style.symbol)) {
-    return _extends({}, style, extractSymbol(style.symbol), {
-      // @ts-ignore
-      children: style.children && style.children.map(extractStyle)
-    });
-  } // NOTE: for cases when style is exist style object should have same reference for all extractStyle calls
-
-
-  return style || {};
-};
-const packStyle = style => {
-  const {
-    ignoreLabel,
-    label,
-    symbol,
-    raster,
-    children
-  } = style,
-        styleDc = _objectWithoutPropertiesLoose(style, _excluded);
-
-  const childSymbols = [!ignoreLabel && label, raster].filter(Boolean);
-  return _extends({}, styleDc, {
-    symbol: childSymbols.length ? // @ts-ignore
-    createCompositeSymbol([symbol, ...childSymbols]) : symbol,
-    // @ts-ignore
-    children: children ? // @ts-ignore
-    children.map(childStyle => packStyle(_extends({}, childStyle, {
-      ignoreLabel,
-      label
-    }))) : children
-  });
-};
-
 let EvergisStyle = /*#__PURE__*/function () {
   function EvergisStyle(style) {
     _classCallCheck(this, EvergisStyle);
@@ -1974,6 +1989,307 @@ const isParameterType = (types, parameter) => {
   })) || false;
 };
 
+(function (FilterConditionOperation) {
+  FilterConditionOperation["AND"] = "&&";
+  FilterConditionOperation["OR"] = "||";
+})(exports.FilterConditionOperation || (exports.FilterConditionOperation = {}));
+
+(function (ComparisonOperator) {
+  /** `==` */
+  ComparisonOperator["Equals"] = "Equals";
+  /** `!=` */
+
+  ComparisonOperator["NotEquals"] = "NotEquals";
+  /** `>` */
+
+  ComparisonOperator["GreaterThan"] = "GreaterThan";
+  /** `<` */
+
+  ComparisonOperator["LessThan"] = "LessThan";
+  /** `>=` */
+
+  ComparisonOperator["GreaterOrEquals"] = "GreaterOrEquals";
+  /** `<=` */
+
+  ComparisonOperator["LessOrEquals"] = "LessOrEquals";
+  ComparisonOperator["Filled"] = "Filled";
+  ComparisonOperator["Empty"] = "Empty";
+  /** `==` */
+
+  ComparisonOperator["Contains"] = "Contains";
+  /** `!=` */
+
+  ComparisonOperator["NotContains"] = "NotContains";
+  ComparisonOperator["StartsWith"] = "StartsWith";
+  ComparisonOperator["NotStartsWith"] = "NotStartsWith";
+  ComparisonOperator["EndsWith"] = "EndsWith";
+  ComparisonOperator["NotEndsWith"] = "NotEndsWith";
+  ComparisonOperator["Between"] = "Between";
+  ComparisonOperator["Outside"] = "Outside";
+})(exports.ComparisonOperator || (exports.ComparisonOperator = {}));
+
+const comparisonOperatorMapReversed = {
+  [condition.TokenType.ArEq]: exports.ComparisonOperator.Equals,
+  [condition.TokenType.ArNotEq]: exports.ComparisonOperator.NotEquals,
+  [condition.TokenType.ArGr]: exports.ComparisonOperator.GreaterThan,
+  [condition.TokenType.ArLs]: exports.ComparisonOperator.LessThan,
+  [condition.TokenType.ArGre]: exports.ComparisonOperator.GreaterOrEquals,
+  [condition.TokenType.ArLse]: exports.ComparisonOperator.LessOrEquals,
+  [condition.TokenType.Between]: exports.ComparisonOperator.Between,
+  [condition.TokenType.Outside]: exports.ComparisonOperator.Outside
+};
+const NUMERIC_ATTRIBUTE_TYPES = [api.AttributeType.Int32, api.AttributeType.Int64, api.AttributeType.DateTime, api.AttributeType.Double];
+
+const formatValue = (value, isDate) => {
+  return isDate ? "#'" + formatDate(value, {
+    dateFormat: exports.DateFormat.UTC,
+    defaultValue: value
+  }) + "'" : value ? value.toString() : 0;
+};
+
+function formatCondition(condition$1) {
+  const {
+    comparisonOperator,
+    value,
+    type,
+    attribute
+  } = condition$1;
+  const operator = OPERATOR_CONDITION_REMAP[comparisonOperator] || comparisonOperator;
+  const preparedValue = typeof value === "string" && value.includes(" - ") ? value.split(" - ") : value;
+  const isDate = type === api.AttributeType.DateTime;
+  const isBetweenOutside = BETWEEN_OPERATORS.includes(comparisonOperator);
+  const escapeValue = !NUMERIC_ATTRIBUTE_TYPES.includes(type) && preparedValue !== null;
+
+  if (isBetweenOutside && Array.isArray(preparedValue) && preparedValue[0] !== undefined) {
+    return OPERATOR_CONDITION_REMAP[comparisonOperator] + "(" + attribute + ", " + formatValue(preparedValue[0], isDate) + ", " + formatValue(preparedValue[1], isDate) + ")";
+  }
+
+  const formattedValue = Array.isArray(preparedValue) ? preparedValue.map(val => formatValue(val, isDate)) : formatValue(preparedValue, isDate);
+  const nulledValue = lodash.isNil(preparedValue) ? "{null}" : formattedValue;
+  const valueEscaped = escapeValue && typeof nulledValue === "string" ? "'" + condition.Char.escapeSpecChars(addOperationToValue(nulledValue, comparisonOperator)) + "'" : nulledValue;
+  return attribute + " " + operator + " " + valueEscaped;
+}
+function createConditionString(condition) {
+  if (Array.isArray(condition)) {
+    return "( " + formatCondition(condition[0]) + " " + condition[0].operation + " " + formatCondition(condition[1]) + " )";
+  }
+
+  return formatCondition(condition);
+}
+function createCondition(_ref) {
+  let {
+    attribute,
+    operation,
+    value
+  } = _ref;
+  const comparisonOperator = comparisonOperatorMapReversed[operation];
+  const convertedResult = convertOperatorValue(value, comparisonOperator);
+  return _extends({
+    attribute
+  }, convertedResult);
+}
+
+function convertOperatorValue(value, comparisonOperator) {
+  if (typeof value === "string") {
+    const operatorIndex = +(comparisonOperator === exports.ComparisonOperator.NotEquals);
+
+    if (value.startsWith(condition.Char.PERCENTAGE) && value.endsWith(condition.Char.PERCENTAGE)) {
+      return {
+        value: value.slice(1, -1),
+        comparisonOperator: CONTAINS_OPERATORS[operatorIndex]
+      };
+    }
+
+    if (value.startsWith(condition.Char.PERCENTAGE)) {
+      return {
+        value: value.slice(1),
+        comparisonOperator: ENDS_WITH_OPERATORS[operatorIndex]
+      };
+    }
+
+    if (value.endsWith(condition.Char.PERCENTAGE)) {
+      return {
+        value: value.slice(0, -1),
+        comparisonOperator: STARTS_WITH_OPERATORS[operatorIndex]
+      };
+    }
+  }
+
+  return {
+    value,
+    comparisonOperator
+  };
+}
+
+const addContains = value => "%" + value + "%";
+
+const addStartsWith = value => value + "%";
+
+const addEndsWith = value => "%" + value;
+
+function addOperationToValue(value, operator) {
+  switch (operator) {
+    case exports.ComparisonOperator.Contains:
+    case exports.ComparisonOperator.NotContains:
+      return addContains(value);
+
+    case exports.ComparisonOperator.StartsWith:
+    case exports.ComparisonOperator.NotStartsWith:
+      return addStartsWith(value);
+
+    case exports.ComparisonOperator.EndsWith:
+    case exports.ComparisonOperator.NotEndsWith:
+      return addEndsWith(value);
+
+    case exports.ComparisonOperator.Between:
+      return condition.Char.BETWEEN;
+
+    case exports.ComparisonOperator.Outside:
+      return condition.Char.OUTSIDE;
+
+    default:
+      return value;
+  }
+}
+
+const OTHERS_TITLE = 'Другое';
+const createLegendItem = _ref => {
+  let {
+    attributes,
+    renderTitle,
+    skipDefaultValue,
+    reverse
+  } = _ref;
+  return classification => {
+    const {
+      defaultTitle,
+      defaultValue,
+      values,
+      attribute: attributeName,
+      parameter
+    } = classification;
+    const attribute = attributeName && attributes ? getClassificationAttribute(attributeName, attributes) : undefined;
+    const defaultLegendValue = {
+      title: defaultTitle || OTHERS_TITLE,
+      parameterValue: defaultValue
+    };
+    const legendValues = values.map((value, index) => ({
+      title: renderTitle && renderTitle(_extends({}, value, {
+        attribute
+      }), index),
+      parameterValue: value.parameterValue
+    }));
+    const withDefault = skipDefaultValue ? legendValues : [...legendValues, defaultLegendValue];
+    const reversedValues = reverse ? [...withDefault].reverse() : withDefault;
+    return {
+      title: attribute && attribute.alias || attributeName,
+      attribute,
+      parameter,
+      values: reversedValues
+    };
+  };
+};
+
+function isValidParameter(parameter) {
+  return !(parameter != null && parameter.includes("labelSymbol")) && !(parameter != null && parameter.includes("singleObjectSymbol"));
+}
+
+function createStyleLegend(style, config) {
+  const {
+    classificationManager,
+    symbol
+  } = style;
+  const items = classificationManager.filter(_ref => {
+    let {
+      parameter
+    } = _ref;
+    return config.parameters && parameter ? config.parameters.includes(parameter) : isValidParameter(parameter);
+  });
+
+  if (!items.length) {
+    return null;
+  }
+
+  return {
+    symbol: unClassify(symbol.singleObjectSymbol || symbol),
+    items: items.map(createLegendItem(config))
+  };
+}
+
+function createValueTitle(value, index) {
+  if (value.title) return value.title;
+  if (isRangeClass(value)) return printRangeClass(value, index);
+  if (isUniqueClass(value)) return value.uniqueValue;
+  return '';
+}
+
+let FilterCondition = /*#__PURE__*/function () {
+  function FilterCondition(condition$1) {
+    if (condition$1 === void 0) {
+      condition$1 = null;
+    }
+
+    _classCallCheck(this, FilterCondition);
+
+    this.condition = condition$1;
+    this.conditionInterpreter = new condition.ConditionInterpreter(condition$1);
+  }
+
+  _createClass(FilterCondition, [{
+    key: "conditions",
+    get: function get() {
+      const {
+        value
+      } = this.conditionInterpreter;
+
+      if (value instanceof Error) {
+        // TODO handle errors in client notifications
+        console.warn(value.message);
+      }
+
+      return value instanceof Error ? [] : value.expressions.map(createCondition);
+    }
+  }, {
+    key: "conditionOperation",
+    get: function get() {
+      const {
+        value
+      } = this.conditionInterpreter;
+
+      if (value instanceof Error) {
+        return null;
+      }
+
+      const isOrCondition = value.boolOperations.includes(condition.TokenType.BoolOr);
+      const isAndCondition = value.boolOperations.includes(condition.TokenType.BoolAnd);
+
+      if (isOrCondition && isAndCondition) {
+        return null;
+      }
+
+      return isOrCondition ? exports.FilterConditionOperation.OR : isAndCondition ? exports.FilterConditionOperation.AND : null;
+    }
+  }, {
+    key: "isParsingError",
+    value: function isParsingError() {
+      return this.conditionInterpreter.value instanceof Error;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.condition;
+    }
+  }], [{
+    key: "from",
+    value: function from(conditions, operation) {
+      const condition = (conditions == null ? void 0 : conditions.map(createConditionString).join(" " + operation + " ")) || null;
+      return new FilterCondition(condition);
+    }
+  }]);
+
+  return FilterCondition;
+}();
+
 const isLayerService = value => isObject(value) && "name" in value;
 const getAttributeFromCondition = condition => {
   const parts = condition.split(" ");
@@ -2007,7 +2323,7 @@ const isRangeCondition = condition => condition.includes("(");
 const getSymbolParameterInfo = parameter => {
   return PARAMETER_INFOS[parameter] || DEFAULT_PARAMETER_INFO;
 };
-const formatValue = (value, type, calculatedParameter) => {
+const formatValue$1 = (value, type, calculatedParameter) => {
   var _ref;
 
   if (type === api.AttributeType.DateTime) {
@@ -2026,7 +2342,7 @@ const formatUniqueClassValue = value => {
     attribute,
     uniqueValue
   } = value;
-  return attribute ? formatValue(uniqueValue, attribute.type) : uniqueValue;
+  return attribute ? formatValue$1(uniqueValue, attribute.type) : uniqueValue;
 };
 const getRangeValues$1 = (_ref2, isDouble, isDate, index) => {
   let {
@@ -2077,7 +2393,7 @@ const getTitleFromCondition = condition => {
   return (_parts$ = parts[1]) == null ? void 0 : _parts$.slice(1, -1);
 };
 
-function createValueTitle(paramValue, attributeType, index) {
+function createValueTitle$1(paramValue, attributeType, index) {
   if (paramValue.title) return paramValue.title;
   const value = {
     parameterValue: getParameterValue(paramValue.value),
@@ -2315,8 +2631,63 @@ const createLegendSymbol = (parameterValue, parameter, classificationsParams, ba
 
   return null;
 };
-const getMinimizedLegendValues = (attributeType, param, index) => {
-  return param.values.map(paramValue => {
+function createHiddenCondition(attributeName, attributeType, value) {
+  let newValue;
+  let comparisonOperator;
+
+  if (isRangeClass(value)) {
+    if (value.from && value.to) {
+      newValue = [value.from, value.to];
+      comparisonOperator = exports.ComparisonOperator.Outside;
+    } else if (value.from) {
+      newValue = value.from;
+      comparisonOperator = exports.ComparisonOperator.LessThan;
+    } else if (value.to) {
+      newValue = value.to;
+      comparisonOperator = exports.ComparisonOperator.GreaterThan;
+    }
+  } else {
+    newValue = value.uniqueValue;
+    comparisonOperator = exports.ComparisonOperator.NotEquals;
+  }
+
+  return new FilterCondition(createConditionString({
+    attribute: attributeName,
+    type: attributeType,
+    comparisonOperator: comparisonOperator,
+    value: newValue
+  })).toString();
+}
+const createOtherHiddenCondition = (values, attributeName, attributeType) => {
+  const value = values[values.length - 1];
+  let hiddenCondition;
+
+  if (isRangeClass(value)) {
+    hiddenCondition = new FilterCondition(createConditionString({
+      attribute: attributeName,
+      type: attributeType,
+      comparisonOperator: exports.ComparisonOperator.LessOrEquals,
+      value: value.to || value.from
+    })).toString();
+  } else {
+    const conditions = values.map(val => new FilterCondition(createConditionString({
+      attribute: attributeName,
+      type: attributeType,
+      comparisonOperator: exports.ComparisonOperator.Equals,
+      value: val.uniqueValue
+    })).toString());
+    hiddenCondition = "( " + conditions.filter(Boolean).join(" " + exports.FilterConditionOperation.OR + " ") + " )";
+  }
+
+  return hiddenCondition;
+};
+const getMinimizedLegendValues = (attributeName, attributeType, classified, index, otherTitle) => {
+  const other = {
+    title: otherTitle,
+    parameterValue: classified.defaultValue,
+    hiddenCondition: createOtherHiddenCondition(classified.values.map(val => getClassificationValue(val.value, otherTitle, new ClassificationCondition(val.condition))), attributeName, attributeType)
+  };
+  const items = classified.values.map(paramValue => {
     const parameterValue = getParameterValue(paramValue.value);
     const result = {
       parameterValue,
@@ -2330,31 +2701,29 @@ const getMinimizedLegendValues = (attributeType, param, index) => {
       const to = getValueFromConditionPart(paramValue.condition, 2);
       result.from = from ? isNumeric(from) ? +from : formatDate(from) : null;
       result.to = to ? isNumeric(to) ? +to : formatDate(to) : null;
-      result.title = createValueTitle(paramValue, attributeType, index);
+      result.title = createValueTitle$1(paramValue, attributeType, index);
       return result;
     }
 
-    result.uniqueValue = formatValue(paramValue.value);
+    result.uniqueValue = formatValue$1(paramValue.value);
     result.title = getTitleFromCondition(paramValue.condition);
+    result.hiddenCondition = createHiddenCondition(attributeName, attributeType, getClassificationValue(paramValue.value, result.title, new ClassificationCondition(paramValue.condition)));
     return result;
   });
+  return [...items, other];
 };
-const getMaximizedLegendValues = (attributeType, param, params, classified, symbol, sectionIndex, otherTitle) => {
+const getMaximizedLegendValues = (attributeName, attributeType, param, params, classified, symbol, sectionIndex, otherTitle) => {
   const other = {
     title: otherTitle,
-    symbol: createLegendSymbol(classified.defaultValue, param, params, symbol)
+    symbol: createLegendSymbol(classified.defaultValue, param, params, symbol),
+    hiddenCondition: createOtherHiddenCondition(classified.values.map(val => getClassificationValue(val.value, otherTitle, new ClassificationCondition(val.condition))), attributeName, attributeType)
   };
   const items = classified.values.map((paramValue, index) => {
     const result = {
       symbol: createLegendSymbol(classified.values[index].value, param, params, symbol)
     };
-
-    if (isRangeCondition(paramValue.condition)) {
-      result.title = createValueTitle(paramValue, attributeType, sectionIndex);
-      return result;
-    }
-
-    result.title = getTitleFromCondition(paramValue.condition);
+    result.title = isRangeCondition(paramValue.condition) ? createValueTitle$1(paramValue, attributeType, sectionIndex) : getTitleFromCondition(paramValue.condition);
+    result.hiddenCondition = createHiddenCondition(attributeName, attributeType, getClassificationValue(classified.values[index].value, result.title, new ClassificationCondition(classified.values[index].condition)));
     return result;
   });
   return [...items, other];
@@ -2492,6 +2861,16 @@ function getAttributeType(layer, attributeName) {
   return attribute ? attribute.type : api.AttributeType.Unknown;
 }
 
+const getClassificationValue = (parameterValue, title, condition) => _extends({
+  parameterValue,
+  title
+}, condition.isUnique() ? {
+  uniqueValue: condition.uniqueValue
+} : {
+  from: condition.range[0],
+  to: condition.range[1]
+});
+
 const metersToPixels = (meters, _ref) => {
   let {
     painter,
@@ -2574,6 +2953,34 @@ const PARAMETER_INFOS = {
 
   })
 };
+const OPERATOR_CONDITION_REMAP = {
+  [exports.ComparisonOperator.Equals]: "==",
+  [exports.ComparisonOperator.NotEquals]: "!=",
+  [exports.ComparisonOperator.GreaterThan]: ">",
+  [exports.ComparisonOperator.GreaterOrEquals]: ">=",
+  [exports.ComparisonOperator.LessThan]: "<",
+  [exports.ComparisonOperator.LessOrEquals]: "<=",
+  [exports.ComparisonOperator.Filled]: "!=",
+  [exports.ComparisonOperator.Empty]: "==",
+  [exports.ComparisonOperator.Contains]: "==",
+  [exports.ComparisonOperator.NotContains]: "!=",
+  [exports.ComparisonOperator.StartsWith]: "==",
+  [exports.ComparisonOperator.NotStartsWith]: "!=",
+  [exports.ComparisonOperator.EndsWith]: "==",
+  [exports.ComparisonOperator.NotEndsWith]: "!=",
+  [exports.ComparisonOperator.Between]: "between",
+  [exports.ComparisonOperator.Outside]: "!between"
+};
+const BASE_OPERATORS = [exports.ComparisonOperator.Equals, exports.ComparisonOperator.NotEquals];
+const CONTAINS_OPERATORS = [exports.ComparisonOperator.Contains, exports.ComparisonOperator.NotContains];
+const FILLED_OPERATORS = [exports.ComparisonOperator.Filled, exports.ComparisonOperator.Empty];
+const STARTS_WITH_OPERATORS = [exports.ComparisonOperator.StartsWith, exports.ComparisonOperator.NotStartsWith];
+const ENDS_WITH_OPERATORS = [exports.ComparisonOperator.EndsWith, exports.ComparisonOperator.NotEndsWith];
+const RANGE_OPERATORS = [exports.ComparisonOperator.LessThan, exports.ComparisonOperator.LessOrEquals, exports.ComparisonOperator.GreaterThan, exports.ComparisonOperator.GreaterOrEquals];
+const BETWEEN_OPERATORS = [exports.ComparisonOperator.Between, exports.ComparisonOperator.Outside];
+const numberComparisonOperators = [...BASE_OPERATORS, ...RANGE_OPERATORS, ...FILLED_OPERATORS, ...BETWEEN_OPERATORS];
+const dateComparisonOperators = [...BASE_OPERATORS, ...RANGE_OPERATORS, ...FILLED_OPERATORS, ...BETWEEN_OPERATORS];
+const textComparisonOperators = [...BASE_OPERATORS, ...CONTAINS_OPERATORS, ...STARTS_WITH_OPERATORS, ...ENDS_WITH_OPERATORS, ...FILLED_OPERATORS];
 
 (function (SvgSymbolBg) {
   SvgSymbolBg["Rect"] = "rect";
@@ -4042,77 +4449,6 @@ const evaluateFeature = layers => feature => {
   return featureLayer ? featureLayer.evaluateFeature(feature) : feature;
 };
 
-const OTHERS_TITLE = 'Другое';
-const createLegendItem = _ref => {
-  let {
-    attributes,
-    renderTitle,
-    skipDefaultValue,
-    reverse
-  } = _ref;
-  return classification => {
-    const {
-      defaultTitle,
-      defaultValue,
-      values,
-      attribute: attributeName,
-      parameter
-    } = classification;
-    const attribute = attributeName && attributes ? getClassificationAttribute(attributeName, attributes) : undefined;
-    const defaultLegendValue = {
-      title: defaultTitle || OTHERS_TITLE,
-      parameterValue: defaultValue
-    };
-    const legendValues = values.map((value, index) => ({
-      title: renderTitle && renderTitle(_extends({}, value, {
-        attribute
-      }), index),
-      parameterValue: value.parameterValue
-    }));
-    const withDefault = skipDefaultValue ? legendValues : [...legendValues, defaultLegendValue];
-    const reversedValues = reverse ? [...withDefault].reverse() : withDefault;
-    return {
-      title: attribute && attribute.alias || attributeName,
-      attribute,
-      parameter,
-      values: reversedValues
-    };
-  };
-};
-
-function isValidParameter(parameter) {
-  return !(parameter != null && parameter.includes("labelSymbol")) && !(parameter != null && parameter.includes("singleObjectSymbol"));
-}
-
-function createStyleLegend(style, config) {
-  const {
-    classificationManager,
-    symbol
-  } = style;
-  const items = classificationManager.filter(_ref => {
-    let {
-      parameter
-    } = _ref;
-    return config.parameters && parameter ? config.parameters.includes(parameter) : isValidParameter(parameter);
-  });
-
-  if (!items.length) {
-    return null;
-  }
-
-  return {
-    symbol: unClassify(symbol.singleObjectSymbol || symbol),
-    items: items.map(createLegendItem(config))
-  };
-}
-
-function createValueTitle$1(value, index) {
-  if (value.title) return value.title;
-  if (isRangeClass(value)) return printRangeClass(value, index);
-  if (isUniqueClass(value)) return value.uniqueValue;
-  return '';
-}
-
 function formatArea(num) {
   let result = num;
   let measure = 'м²';
@@ -4175,7 +4511,7 @@ const useLegend = (style, config) => React.useMemo(() => {
 }, [style, config]);
 
 const DEFAULT_LEGEND_CONFIG = {
-  renderTitle: createValueTitle$1
+  renderTitle: createValueTitle
 };
 const useLayerLegend = (layer, config) => {
   const {
@@ -5589,7 +5925,7 @@ const ItemText = /*#__PURE__*/styled__default.div(_templateObject2$4 || (_templa
 });
 const ItemSeparator = /*#__PURE__*/styled__default.div(_templateObject3$3 || (_templateObject3$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  :after {\n    content: \"-\";\n    margin: 0 0.5rem;\n    font-size: 0.75rem;\n  }\n"])));
 const SymbolContainer = /*#__PURE__*/styled__default("span")(_templateObject4$3 || (_templateObject4$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  justify-content: center;\n  min-width: 16px;\n  margin-right: 0.5rem;\n"])));
-const ClassifiedItem = /*#__PURE__*/styled__default.div(_templateObject5$3 || (_templateObject5$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n  /* cursor: ", ";\n  pointer-events: ", ";*/\n\n  :not(:last-of-type) {\n    margin-bottom: 0.25rem;\n  }\n\n  ", ", ", " {\n    transition: opacity 150ms;\n  }\n\n  ", " {\n    opacity: ", ";\n  }\n\n  ", " {\n    opacity: ", ";\n  }\n\n  /* :hover {\n    ", ", ", " {\n      opacity: 1;\n    }\n  }*/\n"])), _ref2 => {
+const ClassifiedItem = /*#__PURE__*/styled__default.div(_templateObject5$3 || (_templateObject5$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n  cursor: ", ";\n  pointer-events: ", ";\n\n  :not(:last-of-type) {\n    margin-bottom: 0.25rem;\n  }\n\n  ", ", ", " {\n    transition: opacity 150ms;\n  }\n\n  ", " {\n    opacity: ", ";\n  }\n\n  ", " {\n    opacity: ", ";\n  }\n\n  :hover {\n    ", ", ", " {\n      opacity: 1;\n    }\n  }\n"])), _ref2 => {
   let {
     isClusterFillColor
   } = _ref2;
@@ -6000,11 +6336,14 @@ const LegendSymbolRenderer = /*#__PURE__*/React.memo(_ref => {
 
 const MaximizedLegend = _ref => {
   let {
+    layerName,
     symbol: sectionSymbol,
     parameter,
     values,
     index: sectionIndex,
-    attributeType
+    attributeType,
+    hiddenLegends,
+    toggleHiddenLegend
   } = _ref;
   const {
     t
@@ -6044,19 +6383,22 @@ const MaximizedLegend = _ref => {
 
     return React__default.createElement(React__default.Fragment, null, columns.map(renderColumn));
   }, [isDate, renderColumn, t]);
+  const isHidden = React.useCallback(hiddenCondition => !!(hiddenLegends != null && hiddenLegends.includes(hiddenCondition)), [hiddenLegends]);
   const renderLegend = React.useCallback((_ref2, index) => {
     var _parameterValue$value;
 
     let {
       symbol,
-      title
-      /* , hiddenCondition*/
-
+      title,
+      hiddenCondition
     } = _ref2;
-    if (!symbol) return null; // const isClusterFillColor = checkIsClusterFillColor(symbol, parameter);
-
+    if (!symbol) return null;
+    const isClusterFillColor$1 = isClusterFillColor(symbol, parameter);
     return React__default.createElement(ClassifiedItem, {
-      key: sectionIndex + title + index
+      key: sectionIndex + title + index,
+      isHidden: isHidden(hiddenCondition),
+      isClusterFillColor: isClusterFillColor$1,
+      onClick: () => toggleHiddenLegend == null ? void 0 : toggleHiddenLegend(layerName, hiddenCondition)
     }, isSize || isStrokeWidth || isStrokeColor ? React__default.createElement(MapLegendItems, {
       parameter: parameter,
       isSize: isSize,
@@ -6069,11 +6411,9 @@ const MaximizedLegend = _ref => {
       value: (parameterValue == null ? void 0 : (_parameterValue$value = parameterValue.values[index]) == null ? void 0 : _parameterValue$value.value) || (parameterValue == null ? void 0 : parameterValue.defaultValue),
       parameter: parameter
     })) : React__default.createElement(SymbolContainer, null, React__default.createElement(LegendSymbolRenderer, {
-      symbol: symbol
-      /* isClusterFillColor ? symbol : getExtractedSymbol(symbol, true)*/
-
+      symbol: isClusterFillColor$1 ? symbol : getExtractedSymbol(symbol, true)
     })), renderItemText(title, index));
-  }, [isSize, isStrokeColor, isStrokeWidth, parameter, parameterValue == null ? void 0 : parameterValue.defaultValue, parameterValue == null ? void 0 : parameterValue.values, renderItemText, sectionIndex]);
+  }, [isSize, isStrokeColor, isStrokeWidth, parameter, parameterValue == null ? void 0 : parameterValue.defaultValue, parameterValue == null ? void 0 : parameterValue.values, renderItemText, sectionIndex, hiddenLegends, toggleHiddenLegend]);
   return React__default.createElement(React__default.Fragment, null, values.map(renderLegend));
 };
 
@@ -6089,10 +6429,14 @@ const LegendParameterDescription = _ref => {
 
 const LegendSection = _ref => {
   let {
+    layerName,
     symbol,
-    param,
-    params,
+    parameter,
+    parameters,
     classified,
+    hiddenLegends,
+    toggleHiddenLegend,
+    attributeName,
     attributeTitle,
     attributeType,
     index
@@ -6102,54 +6446,58 @@ const LegendSection = _ref => {
   } = reactI18next.useTranslation("common");
   const [isExpanded, toggleExpanded] = useToggle();
   return React__default.createElement(MapLegendSectionContainer, null, React__default.createElement(MapLegendHeader, null, attributeTitle), React__default.createElement(LegendParameterDescription, {
-    parameter: param
+    parameter: parameter
   }), isExpanded ? React__default.createElement(MaximizedLegend, {
-    key: param,
+    layerName: layerName,
     symbol: symbol,
-    parameter: param,
+    hiddenLegends: hiddenLegends == null ? void 0 : hiddenLegends[layerName],
+    toggleHiddenLegend: toggleHiddenLegend,
+    parameter: parameter,
     attributeType: attributeType,
     index: index,
-    values: getMaximizedLegendValues(attributeType, param, params, classified, symbol, index, t("classification.other"))
+    values: getMaximizedLegendValues(attributeName, attributeType, parameter, parameters, classified, symbol, index, t("classification.other"))
   }) : React__default.createElement(MinimizedLegend, {
-    key: param,
-    values: getMinimizedLegendValues(attributeType, classified, index),
-    defaultValue: classified.defaultValue,
-    parameter: param,
-    attributeType: attributeType
+    values: getMinimizedLegendValues(attributeName, attributeType, classified, index, t("classification.other")),
+    hiddenLegends: hiddenLegends == null ? void 0 : hiddenLegends[layerName],
+    parameter: parameter
   }), React__default.createElement(MapLegendExpandButton, {
     onClick: toggleExpanded
   }, t(isExpanded ? "toggleMenu" : "Развернуть")));
 };
 
-const Legend = _ref => {
+const _excluded$3 = ["layerInfo"];
+const Legend = /*#__PURE__*/React.memo(_ref => {
   let {
     layerInfo
-  } = _ref;
+  } = _ref,
+      rest = _objectWithoutPropertiesLoose(_ref, _excluded$3);
+
   const classified = getClassified(layerInfo);
-  const params = Object.keys(classified);
+  const parameters = Object.keys(classified);
   const attributes = getLayerAttributes(layerInfo.layerDefinition);
   return React__default.createElement(MapLegendContainer, null, Object.keys(classified).map((param, index) => {
-    var _classified$param$val, _attributes$find, _layerInfo$style;
+    var _classified$param$val, _layerInfo$style, _attributes$find;
 
     const attributeName = getAttributeNameFromCondition((_classified$param$val = classified[param].values[0]) == null ? void 0 : _classified$param$val.condition);
-    const attributeAlias = (_attributes$find = attributes.find(_ref2 => {
-      let {
-        name
-      } = _ref2;
-      return name === attributeName;
-    })) == null ? void 0 : _attributes$find.alias;
-    return React__default.createElement(LegendSection, {
+    return React__default.createElement(LegendSection, Object.assign({
       key: index,
+      layerName: layerInfo.name,
       symbol: (_layerInfo$style = layerInfo.style) == null ? void 0 : _layerInfo$style.symbol,
+      attributeName: attributeName,
+      attributeTitle: ((_attributes$find = attributes.find(_ref2 => {
+        let {
+          name
+        } = _ref2;
+        return name === attributeName;
+      })) == null ? void 0 : _attributes$find.alias) || attributeName,
       attributeType: getAttributeType(layerInfo, attributeName),
-      attributeTitle: attributeAlias || attributeName,
       classified: classified[param],
-      param: param,
-      params: params,
+      parameter: param,
+      parameters: parameters,
       index: index
-    });
+    }, rest));
   }));
-};
+});
 
 const Map = _ref => {
   let {
@@ -6374,12 +6722,12 @@ let MeasureTool = /*#__PURE__*/function (_React$Component) {
   return MeasureTool;
 }(React__default.Component);
 
-const _excluded$3 = ["isActive"];
+const _excluded$4 = ["isActive"];
 const Measurer = _ref => {
   let {
     isActive
   } = _ref,
-      props = _objectWithoutPropertiesLoose(_ref, _excluded$3);
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$4);
 
   const {
     map,
@@ -6493,7 +6841,7 @@ const TooltipComponent = /*#__PURE__*/styled__default.div(_templateObject11$2 ||
   return withArrow && corner;
 });
 
-const _excluded$4 = ["features", "map", "center", "component", "zIndex", "children", "content", "onEachFeature", "clickMode"];
+const _excluded$5 = ["features", "map", "center", "component", "zIndex", "children", "content", "onEachFeature", "clickMode"];
 
 const {
   Provider,
@@ -6512,7 +6860,7 @@ const Tooltip = _ref => {
     onEachFeature,
     clickMode
   } = _ref,
-      props = _objectWithoutPropertiesLoose(_ref, _excluded$4);
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$5);
 
   const onTooltip = useTooltip(zIndex);
   React.useEffect(() => {
@@ -6554,8 +6902,11 @@ const DraggableMarker = _ref => {
 };
 
 exports.ArrowLineMiterRender = ArrowLineMiterRender;
+exports.BASE_OPERATORS = BASE_OPERATORS;
+exports.BETWEEN_OPERATORS = BETWEEN_OPERATORS;
 exports.BaseMeasureToolCreator = BaseMeasureToolCreator;
 exports.BaseMeasureToolEditor = BaseMeasureToolEditor;
+exports.CONTAINS_OPERATORS = CONTAINS_OPERATORS;
 exports.CRS_MAP = CRS_MAP;
 exports.CardAttributes = CardAttributes;
 exports.CardHeader = CardHeader;
@@ -6579,6 +6930,7 @@ exports.DEFAULT_SYMBOL_SIZE = DEFAULT_SYMBOL_SIZE;
 exports.DEFAULT_SYMBOL_STROKE_COLOR = DEFAULT_SYMBOL_STROKE_COLOR;
 exports.DEFAULT_SYMBOL_WITH_BG_SIZE = DEFAULT_SYMBOL_WITH_BG_SIZE;
 exports.DraggableMarker = DraggableMarker;
+exports.ENDS_WITH_OPERATORS = ENDS_WITH_OPERATORS;
 exports.EXTRA_BORDER_SIZE = EXTRA_BORDER_SIZE;
 exports.EvergisCard = EvergisCard;
 exports.EvergisCardAttribute = EvergisCardAttribute;
@@ -6605,6 +6957,7 @@ exports.EvergisSelectLayer = EvergisSelectLayer;
 exports.EvergisSelectProvider = EvergisSelectProvider;
 exports.EvergisStyle = EvergisStyle;
 exports.EvergisTileLayer = EvergisTileLayer;
+exports.FILLED_OPERATORS = FILLED_OPERATORS;
 exports.FeatureLayer = FeatureLayer;
 exports.Fullscreen = Fullscreen;
 exports.GEOMETRY_ATTRIBUTE = GEOMETRY_ATTRIBUTE;
@@ -6644,13 +6997,16 @@ exports.MinimizedLegend = MinimizedLegend;
 exports.MinimizedLegendContainer = MinimizedLegendContainer;
 exports.NO_CONTENT_VALUE = NO_CONTENT_VALUE;
 exports.Noop = Noop;
+exports.OPERATOR_CONDITION_REMAP = OPERATOR_CONDITION_REMAP;
 exports.PARAMETER_INFOS = PARAMETER_INFOS;
 exports.PREVIEW_LIMITS = PREVIEW_LIMITS;
+exports.RANGE_OPERATORS = RANGE_OPERATORS;
 exports.SGisBrushFill = SGisBrushFill;
 exports.SGisImageFill = SGisImageFill;
 exports.SGisPolygonSymbol = SGisPolygonSymbol;
 exports.SGisPolylineSymbol = SGisPolylineSymbol;
 exports.SOLID_INTERVALS = SOLID_INTERVALS;
+exports.STARTS_WITH_OPERATORS = STARTS_WITH_OPERATORS;
 exports.SVGPoly = SVGPoly;
 exports.SYMBOL_CLASSIFICATION = SYMBOL_CLASSIFICATION;
 exports.SYMBOL_LIMITS = SYMBOL_LIMITS;
@@ -6689,11 +7045,14 @@ exports.clamp = clamp;
 exports.convertSvgToBase64 = convertSvgToBase64;
 exports.copyRings = copyRings;
 exports.createCompositeSymbol = createCompositeSymbol;
+exports.createHiddenCondition = createHiddenCondition;
 exports.createLabelSymbol = createLabelSymbol;
 exports.createLegendSymbol = createLegendSymbol;
+exports.createOtherHiddenCondition = createOtherHiddenCondition;
 exports.createStyleLegend = createStyleLegend;
 exports.createSvgGradient = createSvgGradient;
-exports.createValueTitle = createValueTitle$1;
+exports.createValueTitle = createValueTitle;
+exports.dateComparisonOperators = dateComparisonOperators;
 exports.defaultOffset = defaultOffset;
 exports.defineStrokeStylePreset = defineStrokeStylePreset;
 exports.deserializeSymbol = deserializeSymbol;
@@ -6709,7 +7068,7 @@ exports.formatLength = formatLength;
 exports.formatPolygonMeasure = formatPolygonMeasure;
 exports.formatRangeClassValue = formatRangeClassValue;
 exports.formatUniqueClassValue = formatUniqueClassValue;
-exports.formatValue = formatValue;
+exports.formatValue = formatValue$1;
 exports.getAttributeFromCondition = getAttributeFromCondition;
 exports.getAttributeNameFromClassified = getAttributeNameFromClassified;
 exports.getAttributeNameFromCondition = getAttributeNameFromCondition;
@@ -6722,6 +7081,7 @@ exports.getDashStylePreset = getDashStylePreset;
 exports.getDate = getDate;
 exports.getDimensions = getDimensions;
 exports.getExprFromCondition = getExprFromCondition;
+exports.getExtractedSymbol = getExtractedSymbol;
 exports.getFeatureSymbol = getFeatureSymbol;
 exports.getHexColor = getHexColor;
 exports.getLayerDefinition = getLayerDefinition;
@@ -6747,6 +7107,8 @@ exports.getValueFromConditionPart = getValueFromConditionPart;
 exports.isArrowLineMiter = isArrowLineMiter;
 exports.isCalculatedParameter = isCalculatedParameter;
 exports.isCircleLineMiter = isCircleLineMiter;
+exports.isClusterFillColor = isClusterFillColor;
+exports.isClusterSymbol = isClusterSymbol;
 exports.isCompositeSymbol = isCompositeSymbol;
 exports.isDashedBrush = isDashedBrush;
 exports.isFilledLineMitter = isFilledLineMitter;
@@ -6817,6 +7179,7 @@ exports.measureAreaSymbol = measureAreaSymbol;
 exports.measureLengthSymbol = measureLengthSymbol;
 exports.measurePolygonSnapSymbol = measurePolygonSnapSymbol;
 exports.metersToPixels = metersToPixels;
+exports.numberComparisonOperators = numberComparisonOperators;
 exports.numberWithSpaces = numberWithSpaces;
 exports.packStyle = packStyle;
 exports.phoneHref = phoneHref;
@@ -6834,6 +7197,7 @@ exports.solidStrokeStylePreset = solidStrokeStylePreset;
 exports.strokeStylePresets = strokeStylePresets;
 exports.symbolParameterWalker = symbolParameterWalker;
 exports.symbolTypeGuard = symbolTypeGuard;
+exports.textComparisonOperators = textComparisonOperators;
 exports.toIntervals = toIntervals;
 exports.toLineDash = toLineDash;
 exports.unClassify = unClassify;