@evergis/react 2.0.172 → 2.0.173

package/dist/react.esm.js

@@ -7,7 +7,7 @@ import { DomPainter, MapResize } from '@evergis/sgis/es/painters/DomPainter/DomP
 import { FeatureLayer as FeatureLayer$1 } from '@evergis/sgis/es/layers/FeatureLayer';
 import { Icon, IconButton, EverCloudStatisticsIcon, EverCloudZoomtoIcon, EverCloudCloseIcon, EverCloudPlayPrevIcon, EverCloudPlayNextIcon } from '@evergis/icons';
 import { isValid, toDate, format, parseJSON, parseISO } from 'date-fns';
-import { ConditionInterpreter, TokenType, ConditionEvaluator } from '@evergis/condition';
+import { ConditionInterpreter, TokenType, Char, ConditionEvaluator } from '@evergis/condition';
 import { MultiPoint } from '@evergis/sgis/es/features/MultiPoint';
 import { Polyline } from '@evergis/sgis/es/features/Polyline';
 import { Polygon } from '@evergis/sgis/es/features/Polygon';
@@ -26,6 +26,7 @@ import { LabelFeature } from '@evergis/sgis/es/features/Label';
 import { DrawingFinishEvent } from '@evergis/sgis/es/controls/Control';
 import { PolyEditor } from '@evergis/sgis/es/controls/PolyEditor';
 import get from 'lodash-es/get';
+import { isNil } from 'lodash-es';
 import ReactDOM from 'react-dom';
 import { DynamicPointSymbol, Symbol as Symbol$1 } from '@evergis/sgis/es/symbols/Symbol';
 import { Poly } from '@evergis/sgis/es/features/Poly';
@@ -830,6 +831,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');
@@ -848,6 +902,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');
@@ -1137,59 +1205,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);
@@ -1973,6 +1988,311 @@ const isParameterType = (types, parameter) => {
   })) || false;
 };
 
+var FilterConditionOperation;
+
+(function (FilterConditionOperation) {
+  FilterConditionOperation["AND"] = "&&";
+  FilterConditionOperation["OR"] = "||";
+})(FilterConditionOperation || (FilterConditionOperation = {}));
+
+var ComparisonOperator;
+
+(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";
+})(ComparisonOperator || (ComparisonOperator = {}));
+
+const comparisonOperatorMapReversed = {
+  [TokenType.ArEq]: ComparisonOperator.Equals,
+  [TokenType.ArNotEq]: ComparisonOperator.NotEquals,
+  [TokenType.ArGr]: ComparisonOperator.GreaterThan,
+  [TokenType.ArLs]: ComparisonOperator.LessThan,
+  [TokenType.ArGre]: ComparisonOperator.GreaterOrEquals,
+  [TokenType.ArLse]: ComparisonOperator.LessOrEquals,
+  [TokenType.Between]: ComparisonOperator.Between,
+  [TokenType.Outside]: ComparisonOperator.Outside
+};
+const NUMERIC_ATTRIBUTE_TYPES = [AttributeType.Int32, AttributeType.Int64, AttributeType.DateTime, AttributeType.Double];
+
+const formatValue = (value, isDate) => {
+  return isDate ? "#'" + formatDate(value, {
+    dateFormat: DateFormat.UTC,
+    defaultValue: value
+  }) + "'" : value ? value.toString() : 0;
+};
+
+function formatCondition(condition) {
+  const {
+    comparisonOperator,
+    value,
+    type,
+    attribute
+  } = condition;
+  const operator = OPERATOR_CONDITION_REMAP[comparisonOperator] || comparisonOperator;
+  const preparedValue = typeof value === "string" && value.includes(" - ") ? value.split(" - ") : value;
+  const isDate = type === 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 = isNil(preparedValue) ? "{null}" : formattedValue;
+  const valueEscaped = escapeValue && typeof nulledValue === "string" ? "'" + 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 === ComparisonOperator.NotEquals);
+
+    if (value.startsWith(Char.PERCENTAGE) && value.endsWith(Char.PERCENTAGE)) {
+      return {
+        value: value.slice(1, -1),
+        comparisonOperator: CONTAINS_OPERATORS[operatorIndex]
+      };
+    }
+
+    if (value.startsWith(Char.PERCENTAGE)) {
+      return {
+        value: value.slice(1),
+        comparisonOperator: ENDS_WITH_OPERATORS[operatorIndex]
+      };
+    }
+
+    if (value.endsWith(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 ComparisonOperator.Contains:
+    case ComparisonOperator.NotContains:
+      return addContains(value);
+
+    case ComparisonOperator.StartsWith:
+    case ComparisonOperator.NotStartsWith:
+      return addStartsWith(value);
+
+    case ComparisonOperator.EndsWith:
+    case ComparisonOperator.NotEndsWith:
+      return addEndsWith(value);
+
+    case ComparisonOperator.Between:
+      return Char.BETWEEN;
+
+    case ComparisonOperator.Outside:
+      return 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) {
+    if (condition === void 0) {
+      condition = null;
+    }
+
+    _classCallCheck(this, FilterCondition);
+
+    this.condition = condition;
+    this.conditionInterpreter = new ConditionInterpreter(condition);
+  }
+
+  _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(TokenType.BoolOr);
+      const isAndCondition = value.boolOperations.includes(TokenType.BoolAnd);
+
+      if (isOrCondition && isAndCondition) {
+        return null;
+      }
+
+      return isOrCondition ? FilterConditionOperation.OR : isAndCondition ? 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(" ");
@@ -2006,7 +2326,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 === AttributeType.DateTime) {
@@ -2025,7 +2345,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 {
@@ -2076,7 +2396,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),
@@ -2314,8 +2634,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 = ComparisonOperator.Outside;
+    } else if (value.from) {
+      newValue = value.from;
+      comparisonOperator = ComparisonOperator.LessThan;
+    } else if (value.to) {
+      newValue = value.to;
+      comparisonOperator = ComparisonOperator.GreaterThan;
+    }
+  } else {
+    newValue = value.uniqueValue;
+    comparisonOperator = 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: ComparisonOperator.LessOrEquals,
+      value: value.to || value.from
+    })).toString();
+  } else {
+    const conditions = values.map(val => new FilterCondition(createConditionString({
+      attribute: attributeName,
+      type: attributeType,
+      comparisonOperator: ComparisonOperator.Equals,
+      value: val.uniqueValue
+    })).toString());
+    hiddenCondition = "( " + conditions.filter(Boolean).join(" " + 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,
@@ -2329,31 +2704,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];
@@ -2491,6 +2864,16 @@ function getAttributeType(layer, attributeName) {
   return attribute ? attribute.type : 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,
@@ -2573,6 +2956,34 @@ const PARAMETER_INFOS = {
 
   })
 };
+const OPERATOR_CONDITION_REMAP = {
+  [ComparisonOperator.Equals]: "==",
+  [ComparisonOperator.NotEquals]: "!=",
+  [ComparisonOperator.GreaterThan]: ">",
+  [ComparisonOperator.GreaterOrEquals]: ">=",
+  [ComparisonOperator.LessThan]: "<",
+  [ComparisonOperator.LessOrEquals]: "<=",
+  [ComparisonOperator.Filled]: "!=",
+  [ComparisonOperator.Empty]: "==",
+  [ComparisonOperator.Contains]: "==",
+  [ComparisonOperator.NotContains]: "!=",
+  [ComparisonOperator.StartsWith]: "==",
+  [ComparisonOperator.NotStartsWith]: "!=",
+  [ComparisonOperator.EndsWith]: "==",
+  [ComparisonOperator.NotEndsWith]: "!=",
+  [ComparisonOperator.Between]: "between",
+  [ComparisonOperator.Outside]: "!between"
+};
+const BASE_OPERATORS = [ComparisonOperator.Equals, ComparisonOperator.NotEquals];
+const CONTAINS_OPERATORS = [ComparisonOperator.Contains, ComparisonOperator.NotContains];
+const FILLED_OPERATORS = [ComparisonOperator.Filled, ComparisonOperator.Empty];
+const STARTS_WITH_OPERATORS = [ComparisonOperator.StartsWith, ComparisonOperator.NotStartsWith];
+const ENDS_WITH_OPERATORS = [ComparisonOperator.EndsWith, ComparisonOperator.NotEndsWith];
+const RANGE_OPERATORS = [ComparisonOperator.LessThan, ComparisonOperator.LessOrEquals, ComparisonOperator.GreaterThan, ComparisonOperator.GreaterOrEquals];
+const BETWEEN_OPERATORS = [ComparisonOperator.Between, 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];
 
 var SvgSymbolBg;
 
@@ -4043,77 +4454,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 = 'м²';
@@ -4176,7 +4516,7 @@ const useLegend = (style, config) => useMemo(() => {
 }, [style, config]);
 
 const DEFAULT_LEGEND_CONFIG = {
-  renderTitle: createValueTitle$1
+  renderTitle: createValueTitle
 };
 const useLayerLegend = (layer, config) => {
   const {
@@ -5590,7 +5930,7 @@ const ItemText = /*#__PURE__*/styled.div(_templateObject2$4 || (_templateObject2
 });
 const ItemSeparator = /*#__PURE__*/styled.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("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.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.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;
@@ -6001,11 +6341,14 @@ const LegendSymbolRenderer = /*#__PURE__*/memo(_ref => {
 
 const MaximizedLegend = _ref => {
   let {
+    layerName,
     symbol: sectionSymbol,
     parameter,
     values,
     index: sectionIndex,
-    attributeType
+    attributeType,
+    hiddenLegends,
+    toggleHiddenLegend
   } = _ref;
   const {
     t
@@ -6045,19 +6388,22 @@ const MaximizedLegend = _ref => {
 
     return React.createElement(React.Fragment, null, columns.map(renderColumn));
   }, [isDate, renderColumn, t]);
+  const isHidden = useCallback(hiddenCondition => !!(hiddenLegends != null && hiddenLegends.includes(hiddenCondition)), [hiddenLegends]);
   const renderLegend = 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.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.createElement(MapLegendItems, {
       parameter: parameter,
       isSize: isSize,
@@ -6070,11 +6416,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.createElement(SymbolContainer, null, React.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.createElement(React.Fragment, null, values.map(renderLegend));
 };
 
@@ -6090,10 +6434,14 @@ const LegendParameterDescription = _ref => {
 
 const LegendSection = _ref => {
   let {
+    layerName,
     symbol,
-    param,
-    params,
+    parameter,
+    parameters,
     classified,
+    hiddenLegends,
+    toggleHiddenLegend,
+    attributeName,
     attributeTitle,
     attributeType,
     index
@@ -6103,54 +6451,58 @@ const LegendSection = _ref => {
   } = useTranslation("common");
   const [isExpanded, toggleExpanded] = useToggle();
   return React.createElement(MapLegendSectionContainer, null, React.createElement(MapLegendHeader, null, attributeTitle), React.createElement(LegendParameterDescription, {
-    parameter: param
+    parameter: parameter
   }), isExpanded ? React.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.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.createElement(MapLegendExpandButton, {
     onClick: toggleExpanded
   }, t(isExpanded ? "toggleMenu" : "Развернуть")));
 };
 
-const Legend = _ref => {
+const _excluded$3 = ["layerInfo"];
+const Legend = /*#__PURE__*/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.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.createElement(LegendSection, {
+    return React.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 {
@@ -6375,12 +6727,12 @@ let MeasureTool = /*#__PURE__*/function (_React$Component) {
   return MeasureTool;
 }(React.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,
@@ -6494,7 +6846,7 @@ const TooltipComponent = /*#__PURE__*/styled.div(_templateObject11$2 || (_templa
   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,
@@ -6513,7 +6865,7 @@ const Tooltip = _ref => {
     onEachFeature,
     clickMode
   } = _ref,
-      props = _objectWithoutPropertiesLoose(_ref, _excluded$4);
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$5);
 
   const onTooltip = useTooltip(zIndex);
   useEffect(() => {
@@ -6554,5 +6906,5 @@ const DraggableMarker = _ref => {
   return React.createElement(Fragment, null);
 };
 
-export { ArrowLineMiterRender, BaseMeasureToolCreator, BaseMeasureToolEditor, CRS_MAP, CardAttributes, CardHeader, CircleLineMiterRender, ClassificationCondition, ClassificationManager, ClassifiedItem, ClusterLayer, ClusterSymbol, CompoundIcon, DEFAULT_CRS, DEFAULT_ID_ATTRIBUTE_NAME, DEFAULT_LEGEND_SIZES, DEFAULT_LEGEND_STYLES, DEFAULT_LEGEND_SYMBOL_SIZE, DEFAULT_PARAMETER_INFO, DEFAULT_SRID, DEFAULT_SYMBOL_FILL_COLOR, DEFAULT_SYMBOL_OFFSET, DEFAULT_SYMBOL_SIZE, DEFAULT_SYMBOL_STROKE_COLOR, DEFAULT_SYMBOL_WITH_BG_SIZE, DateFormat, DraggableMarker, EXTRA_BORDER_SIZE, EvergisCard, EvergisCardAttribute, AttributeContainer as EvergisCardAttributeContainer, AttributeTitle as EvergisCardAttributeTitle, AttributeValueContainer as EvergisCardAttributeValueContainer, CardControls as EvergisCardCardControls, CardTitle as EvergisCardCardTitle, EvergisCardContainer, CurrentFeatureIndex as EvergisCardCurrentFeatureIndex, FeatureName as EvergisCardFeatureName, LayerName as EvergisCardLayerName, CardPagination as EvergisCardPagination, PaginationDescription as EvergisCardPaginationDescription, SimpleAttribute as EvergisCardSimpleValue, StickyHeader as EvergisCardStickyHeader, ValueLink as EvergisCardValueLink, EvergisDynamicLayer, EvergisFeature, EvergisLayer, EvergisProvider, EvergisSelect, EvergisSelectLayer, EvergisSelectProvider, EvergisStyle, EvergisTileLayer, FeatureLayer, Fullscreen, GEOMETRY_ATTRIBUTE, ItemSeparator, ItemText, LabelSymbol, Legend, LegendParameterDescription, LegendProvider, LegendSection, LegendSymbolRenderer, LineMiterKind, LineMiterRender, Map, MapControl, MapControls, MapLegendContainer, MapLegendControl, MapLegendDescription, MapLegendDescriptionContainer, MapLegendExpandButton, MapLegendHeader, MapLegendItem, MapLegendItems, MapLegendItemsContainer, MapLegendOther, MapLegendSectionContainer, MapLegendValueDescr, MapLegendValues, MapLegendValuesOther, MapLegendValuesRange, MapProvider, MaximizedLegend, Measure, MeasureTool, Measurer, MinimizedLegend, MinimizedLegendContainer, NO_CONTENT_VALUE, Noop, PARAMETER_INFOS, PREVIEW_LIMITS, SGisBrushFill, SGisImageFill, SGisPolygonSymbol, SGisPolylineSymbol, SOLID_INTERVALS, SVGPoly, SYMBOL_CLASSIFICATION, SYMBOL_LIMITS, SYMBOL_SIZE_PARAMETERS, ScaleRuler, ScaleRulerBlock, ScaleRulerContainer, Search, SelectedPointSymbol, SelectedPolySymbol, ShadowedPointSymbol, ShadowedPolySymbol, SizeMinimizedLegend, SizeMinimizedLegendDown, SizeMinimizedLegendLabel, SizeMinimizedLegendSymbol, SizeMinimizedLegendUp, SquareLineMiterRender, SrId, StyleSymbol, SvgSymbol, SvgSymbolBg, Symbol, SymbolButton, SymbolByType, SymbolContainer, TextContainer, TileLayer, Tooltip, TooltipComponent, TooltipProvider, Zoom, ZoomLevel, adjustSymbol, applyParameterValue, checkLayerHasLegend, clamp, convertSvgToBase64, copyRings, createCompositeSymbol, createLabelSymbol, createLegendSymbol, createStyleLegend, createSvgGradient, createValueTitle$1 as createValueTitle, defaultOffset, defineStrokeStylePreset, deserializeSymbol, evaluateFeature, extractStyle, extractSymbol, findChildFeatureStyle, findChildFeatureSymbol, formatArea, formatAttributeValue, formatDate, formatLength, formatPolygonMeasure, formatRangeClassValue, formatUniqueClassValue, formatValue, getAttributeFromCondition, getAttributeNameFromClassified, getAttributeNameFromCondition, getAttributeType, getAttributesConfiguration, getChildSymbols, getClassified, getCrs, getDashStylePreset, getDate, getDimensions, getExprFromCondition, getFeatureSymbol, getHexColor, getLayerDefinition, getLegendSymbolRenders, getLegendSymbolSize, getLineDash, getMapLegendSymbolRenders, getMapState, getMaximizedLegendValues, getMinimizedLegendValues, getOffsetParameterValue, getParameterFromSymbol, getParameterValue, getRangeValues$1 as getRangeValues, getScale, getServiceConfiguration, getSignFromConditionPart, getSymbolParameterInfo, getSymbolRenders, getSymbolStrokeWidth, getTitleFromCondition, getValueFromConditionPart, isArrowLineMiter, isCalculatedParameter, isCircleLineMiter, isCompositeSymbol, isDashedBrush, isFilledLineMitter, isH3GridSymbol, isHatchBrush, isImageSymbol, isLabelSymbol, isLayerService, isMaskedImageSymbol, isMiterExist, isNumeric, isObject, isParameterByAttribute, isParameterType, isParameterValueSimple, isParameterValueSymbol, isPatternBrush, isPointLabelSymbol, isPointSymbol, isPolygonHasHatchBrush, isPolygonHasPatternBrush, isPolygonLabelSymbol, isPolygonSymbol, isPolylineLabelSymbol, isPolylineLikePolygon, isPolylineSymbol, isPolylineSymbols, isRangeClass, isRangeCondition, isRasterSymbol, isRequisiteNumbers, isSGisClusterSymbol, isSGisH3Symbol, isSGisImageSymbol, isSGisPointSymbol, isSGisPolygonSymbol, isSGisPolylineSymbol, isScalablePolylineSymbol, isSimpleOffset, isSimplePolylineSymbol, isSimpleSymbol, isSizableSymbol, isSizeClassification, isSolidBrush, isSquareLineMiter, isSquareSymbol, isStaticImageSymbol, isStringAsInn, isStringAsKpp, isStringAsMail, isStringAsOgrn, isStringAsPhone, isStringAsUrl, isStringContainsDate, isStringParameterValue, isStrokeStyledSymbol, isStyle, isSvgPointSymbol, isSymbolWithOffset, isTwoDimensionalSymbol, isUniqueClass, isValidParameter, isValidUrl, mailHref, manipulateSvgSymbol, matchPhone, measureAreaSymbol, measureLengthSymbol, measurePolygonSnapSymbol, metersToPixels, numberWithSpaces, packStyle, phoneHref, polygonCircleFromPoint, printRangeClass, renderSymbolToCanvas, selectedPoint, selectedPolygon, selectedPolyline, serializeSvgPointSymbol, setDefaultParameterValue, setParameterValue, shouldUpdateMapState, solidStrokeStylePreset, strokeStylePresets, symbolParameterWalker, symbolTypeGuard, toIntervals, toLineDash, unClassify, updateMapResolution, updateSymbolParameter, urlHref, useCanvas, useClusterLayer, useCrs, useDebouncedCallback, useDraggableMarker, useEventPoint, useEvergisContext, useEvergisDynamicLayer, useEvergisSelect, useEvergisSelectContext, useEvergisTileLayer, useFeatureLayer, useLayerLegend, useLayerOrder, useLayerVisibility, useLegend, useLegendContext, useLegendValueSymbol, useMapBboxChange, useMapContext, useMapLegend, useMapLevel, useMapPick, useMapResize, useMapState, useMapView, useMapViewActions, useMapWrapper, useMaxMinScale, useMetersToPixels, useMetersToPixelsCb, useMount, useProperty, useScale, useSvgSymbol, useSymbol, useToggle, useTooltip, useTooltipContext, useUpdate, useUpdateMapView };
+export { ArrowLineMiterRender, BASE_OPERATORS, BETWEEN_OPERATORS, BaseMeasureToolCreator, BaseMeasureToolEditor, CONTAINS_OPERATORS, CRS_MAP, CardAttributes, CardHeader, CircleLineMiterRender, ClassificationCondition, ClassificationManager, ClassifiedItem, ClusterLayer, ClusterSymbol, ComparisonOperator, CompoundIcon, DEFAULT_CRS, DEFAULT_ID_ATTRIBUTE_NAME, DEFAULT_LEGEND_SIZES, DEFAULT_LEGEND_STYLES, DEFAULT_LEGEND_SYMBOL_SIZE, DEFAULT_PARAMETER_INFO, DEFAULT_SRID, DEFAULT_SYMBOL_FILL_COLOR, DEFAULT_SYMBOL_OFFSET, DEFAULT_SYMBOL_SIZE, DEFAULT_SYMBOL_STROKE_COLOR, DEFAULT_SYMBOL_WITH_BG_SIZE, DateFormat, DraggableMarker, ENDS_WITH_OPERATORS, EXTRA_BORDER_SIZE, EvergisCard, EvergisCardAttribute, AttributeContainer as EvergisCardAttributeContainer, AttributeTitle as EvergisCardAttributeTitle, AttributeValueContainer as EvergisCardAttributeValueContainer, CardControls as EvergisCardCardControls, CardTitle as EvergisCardCardTitle, EvergisCardContainer, CurrentFeatureIndex as EvergisCardCurrentFeatureIndex, FeatureName as EvergisCardFeatureName, LayerName as EvergisCardLayerName, CardPagination as EvergisCardPagination, PaginationDescription as EvergisCardPaginationDescription, SimpleAttribute as EvergisCardSimpleValue, StickyHeader as EvergisCardStickyHeader, ValueLink as EvergisCardValueLink, EvergisDynamicLayer, EvergisFeature, EvergisLayer, EvergisProvider, EvergisSelect, EvergisSelectLayer, EvergisSelectProvider, EvergisStyle, EvergisTileLayer, FILLED_OPERATORS, FeatureLayer, FilterConditionOperation, Fullscreen, GEOMETRY_ATTRIBUTE, ItemSeparator, ItemText, LabelSymbol, Legend, LegendParameterDescription, LegendProvider, LegendSection, LegendSymbolRenderer, LineMiterKind, LineMiterRender, Map, MapControl, MapControls, MapLegendContainer, MapLegendControl, MapLegendDescription, MapLegendDescriptionContainer, MapLegendExpandButton, MapLegendHeader, MapLegendItem, MapLegendItems, MapLegendItemsContainer, MapLegendOther, MapLegendSectionContainer, MapLegendValueDescr, MapLegendValues, MapLegendValuesOther, MapLegendValuesRange, MapProvider, MaximizedLegend, Measure, MeasureTool, Measurer, MinimizedLegend, MinimizedLegendContainer, NO_CONTENT_VALUE, Noop, OPERATOR_CONDITION_REMAP, PARAMETER_INFOS, PREVIEW_LIMITS, RANGE_OPERATORS, SGisBrushFill, SGisImageFill, SGisPolygonSymbol, SGisPolylineSymbol, SOLID_INTERVALS, STARTS_WITH_OPERATORS, SVGPoly, SYMBOL_CLASSIFICATION, SYMBOL_LIMITS, SYMBOL_SIZE_PARAMETERS, ScaleRuler, ScaleRulerBlock, ScaleRulerContainer, Search, SelectedPointSymbol, SelectedPolySymbol, ShadowedPointSymbol, ShadowedPolySymbol, SizeMinimizedLegend, SizeMinimizedLegendDown, SizeMinimizedLegendLabel, SizeMinimizedLegendSymbol, SizeMinimizedLegendUp, SquareLineMiterRender, SrId, StyleSymbol, SvgSymbol, SvgSymbolBg, Symbol, SymbolButton, SymbolByType, SymbolContainer, TextContainer, TileLayer, Tooltip, TooltipComponent, TooltipProvider, Zoom, ZoomLevel, adjustSymbol, applyParameterValue, checkLayerHasLegend, clamp, convertSvgToBase64, copyRings, createCompositeSymbol, createHiddenCondition, createLabelSymbol, createLegendSymbol, createOtherHiddenCondition, createStyleLegend, createSvgGradient, createValueTitle, dateComparisonOperators, defaultOffset, defineStrokeStylePreset, deserializeSymbol, evaluateFeature, extractStyle, extractSymbol, findChildFeatureStyle, findChildFeatureSymbol, formatArea, formatAttributeValue, formatDate, formatLength, formatPolygonMeasure, formatRangeClassValue, formatUniqueClassValue, formatValue$1 as formatValue, getAttributeFromCondition, getAttributeNameFromClassified, getAttributeNameFromCondition, getAttributeType, getAttributesConfiguration, getChildSymbols, getClassified, getCrs, getDashStylePreset, getDate, getDimensions, getExprFromCondition, getExtractedSymbol, getFeatureSymbol, getHexColor, getLayerDefinition, getLegendSymbolRenders, getLegendSymbolSize, getLineDash, getMapLegendSymbolRenders, getMapState, getMaximizedLegendValues, getMinimizedLegendValues, getOffsetParameterValue, getParameterFromSymbol, getParameterValue, getRangeValues$1 as getRangeValues, getScale, getServiceConfiguration, getSignFromConditionPart, getSymbolParameterInfo, getSymbolRenders, getSymbolStrokeWidth, getTitleFromCondition, getValueFromConditionPart, isArrowLineMiter, isCalculatedParameter, isCircleLineMiter, isClusterFillColor, isClusterSymbol, isCompositeSymbol, isDashedBrush, isFilledLineMitter, isH3GridSymbol, isHatchBrush, isImageSymbol, isLabelSymbol, isLayerService, isMaskedImageSymbol, isMiterExist, isNumeric, isObject, isParameterByAttribute, isParameterType, isParameterValueSimple, isParameterValueSymbol, isPatternBrush, isPointLabelSymbol, isPointSymbol, isPolygonHasHatchBrush, isPolygonHasPatternBrush, isPolygonLabelSymbol, isPolygonSymbol, isPolylineLabelSymbol, isPolylineLikePolygon, isPolylineSymbol, isPolylineSymbols, isRangeClass, isRangeCondition, isRasterSymbol, isRequisiteNumbers, isSGisClusterSymbol, isSGisH3Symbol, isSGisImageSymbol, isSGisPointSymbol, isSGisPolygonSymbol, isSGisPolylineSymbol, isScalablePolylineSymbol, isSimpleOffset, isSimplePolylineSymbol, isSimpleSymbol, isSizableSymbol, isSizeClassification, isSolidBrush, isSquareLineMiter, isSquareSymbol, isStaticImageSymbol, isStringAsInn, isStringAsKpp, isStringAsMail, isStringAsOgrn, isStringAsPhone, isStringAsUrl, isStringContainsDate, isStringParameterValue, isStrokeStyledSymbol, isStyle, isSvgPointSymbol, isSymbolWithOffset, isTwoDimensionalSymbol, isUniqueClass, isValidParameter, isValidUrl, mailHref, manipulateSvgSymbol, matchPhone, measureAreaSymbol, measureLengthSymbol, measurePolygonSnapSymbol, metersToPixels, numberComparisonOperators, numberWithSpaces, packStyle, phoneHref, polygonCircleFromPoint, printRangeClass, renderSymbolToCanvas, selectedPoint, selectedPolygon, selectedPolyline, serializeSvgPointSymbol, setDefaultParameterValue, setParameterValue, shouldUpdateMapState, solidStrokeStylePreset, strokeStylePresets, symbolParameterWalker, symbolTypeGuard, textComparisonOperators, toIntervals, toLineDash, unClassify, updateMapResolution, updateSymbolParameter, urlHref, useCanvas, useClusterLayer, useCrs, useDebouncedCallback, useDraggableMarker, useEventPoint, useEvergisContext, useEvergisDynamicLayer, useEvergisSelect, useEvergisSelectContext, useEvergisTileLayer, useFeatureLayer, useLayerLegend, useLayerOrder, useLayerVisibility, useLegend, useLegendContext, useLegendValueSymbol, useMapBboxChange, useMapContext, useMapLegend, useMapLevel, useMapPick, useMapResize, useMapState, useMapView, useMapViewActions, useMapWrapper, useMaxMinScale, useMetersToPixels, useMetersToPixelsCb, useMount, useProperty, useScale, useSvgSymbol, useSymbol, useToggle, useTooltip, useTooltipContext, useUpdate, useUpdateMapView };
 //# sourceMappingURL=react.esm.js.map