@retailcrm/datalens-ui 0.0.0

package/components/DialogFilter.js

@@ -0,0 +1,3735 @@
+import omit from "lodash/omit";
+import pick from "lodash/pick";
+import { l as I18n, aZ as DATASET_FIELD_TYPES, bz as LabelsPositions, b6 as isParameter, bA as DatasetFieldAggregation, D as DL, bB as PlaceholderId, bC as isMeasureNameOrValue, bD as createMeasureNames, bE as isMeasureName, bF as isMeasureValue, bG as isMarkupField, j as i18n$5, bH as GradientNullModes, $ as GradientType, _ as selectDefaultClientGradient, bv as WizardVisualizationId, f as getAvailableClientPalettesMap, bI as isVisualizationWithLayers, bJ as isDateField, aX as Operations, af as resolveOperation, bK as NavigatorModes, bm as resolveRelativeDate, bl as resolveIntervalDate, b5 as DatasetFieldType, bL as isFieldHierarchy, bM as isMeasureField, bN as PlaceholderIndexes, bO as AxisNullsMode, bP as AxisAutoScaleModes, bQ as LegendDisplayMode, bR as AxisMode, bS as AxisLabelFormatMode, bT as getResultSchemaFromDataset, bU as isPseudoField, bV as getSortedData, bW as ChartsConfigVersion, bf as getFieldsApiV2RequestSection, bX as getParametersApiV2RequestSection, bg as TIMEOUT_90_SEC } from "./AccessRights.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import React__default from "react";
+import { RadioGroup, TextInput, Button, Icon, Loader, List, Dialog, Select } from "@gravity-ui/uikit";
+import block from "bem-cn-lite";
+import { D as DialogManager } from "./DialogManager.js";
+import _, { pick as pick$1 } from "lodash";
+import { K as BASE_EQUALITY_OPERATIONS, L as BASE_COMPARSION_OPERATIONS, M as BASE_NULL_OPERATIONS, O as BASE_SET_OPERATIONS, Q as BASE_STRING_OPERATIONS, R as BASE_DATE_OPERATIONS, T as ADDITIONAL_ARRAY_OPERATIONS, U as BASE_ARRAY_OPERATIONS, V as getWhereOperation, W as getFilterOperations, X as NO_SELECTED_VALUES_OPERATION } from "./ControlComponents.js";
+import { z as getRouter, r as getLocation, g as getSdk, l as logger, T as withHiddenUnmount } from "./ActionPanel.js";
+import { D as DataTypeIcon } from "./DataTypeIcon.js";
+import { D as DatasetFieldList } from "./DatasetFieldList.js";
+import { R as RelativeDatesPicker } from "./RelativeDatesPicker.js";
+import { i as iconPlus } from "./ColorPaletteEditorContainer.js";
+import { LayoutColumns3, LayoutRows3, SquareHashtag, GeoDots, ChevronsExpandUpRight, GeoPolygons, BucketPaint, ChartPie, ArrowRight, ArrowUp, ArrowDown, Circles5Random, SquareLetterT, BranchesDown, SquareBracketsLetterA, SquareBracketsBarsVertical, Hierarchy, CopyCheckXmark, Calendar, Hashtag } from "@gravity-ui/icons";
+import isEqual from "lodash/isEqual";
+import moment from "moment";
+import cloneDeep from "lodash/cloneDeep";
+import { v1 } from "uuid";
+const b$4 = block("dl-dialog-filter");
+const i18n$4 = I18n.keyset("component.dl-dialog-filter.view");
+const BooleanFilter = (props) => {
+  const { values, changeValue } = props;
+  const onChange = React__default.useCallback(
+    (e) => {
+      changeValue([e.target.value]);
+    },
+    [changeValue]
+  );
+  return /* @__PURE__ */ jsxs("div", { className: b$4("filter-boolean"), children: [
+    /* @__PURE__ */ jsx("div", { className: b$4("label"), children: /* @__PURE__ */ jsx("span", { children: i18n$4("label_value") }) }),
+    /* @__PURE__ */ jsxs(
+      RadioGroup,
+      {
+        value: (values[0] || "").toLowerCase(),
+        onChange,
+        children: [
+          /* @__PURE__ */ jsx(RadioGroup.Option, { content: "true", value: "true" }),
+          /* @__PURE__ */ jsx(RadioGroup.Option, { content: "false", value: "false" })
+        ]
+      }
+    )
+  ] });
+};
+const b$3 = block("dl-dialog-filter");
+const DateFilter = (props) => {
+  const { values, field, operation, changeValue } = props;
+  const { data_type: dataType } = field;
+  const onChange = React__default.useCallback(
+    (value, { valid }) => {
+      changeValue([value], { valid });
+    },
+    [changeValue]
+  );
+  return /* @__PURE__ */ jsx("div", { className: b$3("filter-date"), children: /* @__PURE__ */ jsx(
+    RelativeDatesPicker,
+    {
+      range: operation.range,
+      value: values[0],
+      withTime: dataType === DATASET_FIELD_TYPES.GENERICDATETIME,
+      onChange
+    }
+  ) });
+};
+const iconCross = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2024%2024'%3e%3cg%20stroke='none'%20stroke-width='1'%20fill='none'%20fill-rule='evenodd'%3e%3cpath%20d='M7.35714286,7.35714286%20L16.6428571,16.6428571'%20stroke='currentColor'%20stroke-width='2'%20strokeLinecap='round'%3e%3c/path%3e%3cpath%20d='M7.35714286,7.35714286%20L16.6428571,16.6428571'%20stroke='currentColor'%20stroke-width='2'%20strokeLinecap='round'%20transform='translate(12.000000,%2012.000000)%20scale(-1,%201)%20translate(-12.000000,%20-12.000000)%20'%3e%3c/path%3e%3c/g%3e%3c/svg%3e";
+const b$2 = block("dl-dialog-filter");
+const i18n$3 = I18n.keyset("component.dl-dialog-filter.view");
+const InputFilter = (props) => {
+  const { values, selectable, changeValue } = props;
+  const onAddButtonClick = React__default.useCallback(() => {
+    changeValue([...values, ""], { needSort: false });
+  }, [values, changeValue]);
+  const onDeleteButtonClick = React__default.useCallback(
+    (index) => {
+      const newValues = [...values];
+      newValues.splice(index, 1);
+      changeValue(newValues, { needSort: false });
+    },
+    [values, changeValue]
+  );
+  const onChange = React__default.useCallback(
+    (newValue, index) => {
+      let newValues = [...values];
+      if (selectable && values.length > 1) {
+        newValues[index] = newValue;
+      } else if (newValue) {
+        newValues = [newValue];
+      } else {
+        newValues = [];
+      }
+      changeValue(newValues, { needSort: false });
+    },
+    [values, selectable, changeValue]
+  );
+  const renderInput = React__default.useCallback(
+    (value, index = 0) => /* @__PURE__ */ jsxs("div", { className: b$2("row"), children: [
+      /* @__PURE__ */ jsx("div", { className: b$2("label"), children: /* @__PURE__ */ jsx("span", { children: `${i18n$3("label_value")} ${selectable ? index + 1 : ""}` }) }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          className: b$2("filter-input-item"),
+          value,
+          onUpdate: (newValue) => onChange(newValue, index)
+        }
+      ),
+      selectable && values.length > 1 && /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: b$2("delete-button"),
+          view: "flat",
+          onClick: () => onDeleteButtonClick(index),
+          children: /* @__PURE__ */ jsx(Icon, { data: iconCross, size: 16 })
+        }
+      )
+    ] }),
+    [values, onChange, onDeleteButtonClick, selectable]
+  );
+  return /* @__PURE__ */ jsx("div", { className: b$2("filter-input"), children: selectable ? /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    values.map(renderInput),
+    /* @__PURE__ */ jsxs(Button, { onClick: onAddButtonClick, children: [
+      /* @__PURE__ */ jsx(Icon, { data: iconPlus, width: "16" }),
+      i18n$3("button_add")
+    ] })
+  ] }) : renderInput(values[0]) });
+};
+const LIST_ITEM_HEIGHT = 40;
+const NULL_TITLE = "null";
+const DIMENSION_NUMBER_OPERATIONS = [
+  ...BASE_SET_OPERATIONS.map((item) => ({ ...item, selectable: true })),
+  ...BASE_EQUALITY_OPERATIONS,
+  ...BASE_COMPARSION_OPERATIONS,
+  ...BASE_NULL_OPERATIONS
+];
+const MEASURE_NUMBER_OPERATIONS = [
+  ...BASE_EQUALITY_OPERATIONS,
+  ...BASE_COMPARSION_OPERATIONS,
+  ...BASE_NULL_OPERATIONS
+];
+const STRING_OPERATIONS = [
+  ...BASE_SET_OPERATIONS.map((item) => ({ ...item, selectable: true })),
+  ...BASE_EQUALITY_OPERATIONS,
+  ...BASE_STRING_OPERATIONS,
+  ...BASE_NULL_OPERATIONS,
+  ...BASE_COMPARSION_OPERATIONS
+];
+const BOOLEAN_OPERATIONS = [
+  ...BASE_EQUALITY_OPERATIONS,
+  ...BASE_NULL_OPERATIONS
+];
+const DATE_OPERATIONS = [
+  ...BASE_DATE_OPERATIONS.map((item) => ({ ...item, range: true })),
+  ...BASE_EQUALITY_OPERATIONS.map((item) => ({ ...item, range: false })),
+  ...BASE_COMPARSION_OPERATIONS.map((item) => ({ ...item, range: false })),
+  ...BASE_NULL_OPERATIONS.map((item) => ({ ...item, range: false })),
+  ...BASE_SET_OPERATIONS.map((item) => ({ ...item, selectable: true }))
+];
+const ARRAY_OPERATIONS = [
+  ...BASE_EQUALITY_OPERATIONS,
+  ...ADDITIONAL_ARRAY_OPERATIONS,
+  ...BASE_ARRAY_OPERATIONS,
+  ...BASE_NULL_OPERATIONS
+];
+const b$1 = block("dl-dialog-filter");
+const i18n$2 = I18n.keyset("component.dl-dialog-filter.view");
+class SelectFilter extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      leftFilter: "",
+      rightFilter: ""
+    };
+    this.getListItemRenderer = (type) => {
+      const renderListItem = ({ value, disabled }) => {
+        const title = disabled ? NULL_TITLE : value;
+        return /* @__PURE__ */ jsxs("div", { className: b$1("select-column-item"), children: [
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: b$1("select-column-item-label", { empty: disabled }),
+              title: title || "",
+              children: title
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: b$1("select-column-item-description"), children: i18n$2(`label_select-column-${type}-item-desc`) })
+        ] });
+      };
+      return renderListItem;
+    };
+  }
+  render() {
+    return /* @__PURE__ */ jsxs("div", { className: b$1("filter-select"), children: [
+      this.renderLeftColumn(),
+      this.renderRightColumn()
+    ] });
+  }
+  renderLeftColumn() {
+    const { values, changeValue, useSuggest, suggestFetching } = this.props;
+    const { leftFilter } = this.state;
+    const items = this.leftItems;
+    const filteredItems = items.filter(({ value }) => value !== null && value !== void 0);
+    return /* @__PURE__ */ jsxs("div", { className: b$1("select-column", { [
+      "left"
+      /* Left */
+    ]: true }), children: [
+      /* @__PURE__ */ jsxs("div", { className: b$1("select-column-header"), children: [
+        i18n$2("label_select-column-left-title"),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            view: "flat-secondary",
+            disabled: !filteredItems.length,
+            onClick: () => {
+              const newValues = [...values, ...filteredItems.map(({ value }) => value)];
+              changeValue(newValues);
+            },
+            children: i18n$2("button_left-column-action")
+          }
+        )
+      ] }),
+      suggestFetching && /* @__PURE__ */ jsx("div", { className: b$1("select-column-loader"), children: /* @__PURE__ */ jsx(Loader, {}) }),
+      /* @__PURE__ */ jsx("div", { className: b$1("select-column-items", { disabled: suggestFetching }), children: /* @__PURE__ */ jsx(
+        List,
+        {
+          items,
+          itemHeight: LIST_ITEM_HEIGHT,
+          filter: leftFilter,
+          filterPlaceholder: i18n$2("label_filter-placeholder"),
+          renderItem: this.getListItemRenderer(
+            "left"
+            /* Left */
+          ),
+          onItemClick: (item) => {
+            let newValues = [...values];
+            if (!leftFilter && values.length && !this.rightItems.length) {
+              newValues = [];
+            }
+            newValues.push(item.value);
+            changeValue(newValues);
+          },
+          onFilterUpdate: (newFilter) => {
+            if (useSuggest) {
+              this.props.onChangeSuggest(newFilter);
+            }
+            this.setState({ leftFilter: newFilter });
+          }
+        }
+      ) })
+    ] });
+  }
+  renderRightColumn() {
+    const { values, changeValue, suggestFetching } = this.props;
+    const { rightFilter } = this.state;
+    const mods = {
+      [
+        "right"
+        /* Right */
+      ]: true,
+      disabled: suggestFetching
+    };
+    const items = this.rightItems;
+    return /* @__PURE__ */ jsxs("div", { className: b$1("select-column", mods), children: [
+      /* @__PURE__ */ jsxs("div", { className: b$1("select-column-header"), children: [
+        i18n$2("label_select-column-right-title"),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            view: "flat-secondary",
+            disabled: !items.length,
+            onClick: () => {
+              const newValues = _.without(values, ...items.map(({ value }) => value));
+              changeValue(newValues);
+            },
+            children: i18n$2("button_right-column-action")
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: b$1("select-column-items"), children: /* @__PURE__ */ jsx(
+        List,
+        {
+          items,
+          itemHeight: LIST_ITEM_HEIGHT,
+          filter: rightFilter,
+          filterPlaceholder: i18n$2("label_filter-placeholder"),
+          renderItem: this.getListItemRenderer(
+            "right"
+            /* Right */
+          ),
+          onItemClick: (item) => {
+            const newValues = values.filter((value) => value !== item.value);
+            changeValue(newValues);
+          },
+          onFilterUpdate: (newFilter) => this.setState({ rightFilter: newFilter })
+        }
+      ) })
+    ] });
+  }
+  get leftItems() {
+    const { values, dimensions, useSuggest } = this.props;
+    const { leftFilter } = this.state;
+    const items = _.without(dimensions, ...values).map((value) => ({
+      value,
+      disabled: value === null || value === void 0
+    }));
+    if (leftFilter && !useSuggest) {
+      const filterInLowerCase = leftFilter.toLowerCase();
+      return items.filter(({ value }) => value?.toLowerCase().includes(filterInLowerCase));
+    }
+    return items;
+  }
+  get rightItems() {
+    const { values } = this.props;
+    const { rightFilter } = this.state;
+    const items = values.map((value) => ({
+      value,
+      disabled: value === null || value === void 0
+    }));
+    if (rightFilter) {
+      const filterInLowerCase = rightFilter.toLowerCase();
+      return items.filter(({ value }) => value?.toLowerCase().includes(filterInLowerCase));
+    }
+    return items;
+  }
+}
+var ViewMode = /* @__PURE__ */ ((ViewMode2) => {
+  ViewMode2["Fields"] = "fields";
+  ViewMode2["Filters"] = "filters";
+  return ViewMode2;
+})(ViewMode || {});
+const ITEM_TYPES = {
+  DIMENSIONS: /* @__PURE__ */ new Set(["DIMENSION"]),
+  MEASURES: /* @__PURE__ */ new Set(["MEASURE"]),
+  DIMENSIONS_AND_PSEUDO: /* @__PURE__ */ new Set(["DIMENSION", "PSEUDO"]),
+  MEASURES_AND_PSEUDO: /* @__PURE__ */ new Set(["MEASURE", "PSEUDO"]),
+  DIMENSIONS_AND_MEASURES: /* @__PURE__ */ new Set(["DIMENSION", "MEASURE"]),
+  ALL: /* @__PURE__ */ new Set(["DIMENSION", "MEASURE", "PSEUDO"]),
+  NIL: /* @__PURE__ */ new Set([]),
+  PARAMETERS: /* @__PURE__ */ new Set(["PARAMETERS"])
+};
+const CONFLICT_TOOLTIPS = {
+  "not-existing": "label_field-not-exist",
+  "not-existing-ql": "label_field-not-exist-in-query",
+  "wrong-type": "label_field-has-wrong-type",
+  invalid: "label_field-invalid",
+  "link-failed": "label_link-failed",
+  "more-than-one-hierarchy": "label_field-more-than-one-hierarchy"
+};
+const DATASET_ERRORS = {
+  "403-dataset": "label_error-dataset-no-access-rights",
+  "403-connection": "label_error-connection-no-access-rights",
+  404: "label_error-dataset-not-found",
+  500: "label_error-dataset-server-error",
+  UNKNOWN: "label_error-dataset-unknown-error"
+};
+const AVAILABLE_FIELD_TYPES = [
+  DATASET_FIELD_TYPES.STRING,
+  DATASET_FIELD_TYPES.INTEGER,
+  DATASET_FIELD_TYPES.FLOAT,
+  DATASET_FIELD_TYPES.DATE,
+  DATASET_FIELD_TYPES.GENERICDATETIME,
+  DATASET_FIELD_TYPES.DATETIMETZ,
+  DATASET_FIELD_TYPES.BOOLEAN,
+  DATASET_FIELD_TYPES.GEOPOINT,
+  DATASET_FIELD_TYPES.GEOPOLYGON
+];
+const HIDE_LABEL_MODES = {
+  DEFAULT: "show"
+};
+const CLIENT_SIDE_FIELD_PROPS = [
+  "local",
+  "quickFormula",
+  "format",
+  "grouping",
+  "originalDateCast",
+  "originalSource",
+  "originalTitle",
+  "originalFormula",
+  "fakeTitle",
+  "datasetId",
+  "asPseudo",
+  "columnSettings",
+  "backgroundSettings",
+  "barsSettings"
+];
+const PRIMITIVE_DATA_TYPES = /* @__PURE__ */ new Set([
+  DATASET_FIELD_TYPES.INTEGER,
+  DATASET_FIELD_TYPES.UINTEGER,
+  DATASET_FIELD_TYPES.FLOAT,
+  DATASET_FIELD_TYPES.DATE,
+  DATASET_FIELD_TYPES.GENERICDATETIME,
+  DATASET_FIELD_TYPES.DATETIMETZ,
+  DATASET_FIELD_TYPES.BOOLEAN,
+  DATASET_FIELD_TYPES.STRING,
+  DATASET_FIELD_TYPES.ARRAY_STR,
+  DATASET_FIELD_TYPES.ARRAY_INT,
+  DATASET_FIELD_TYPES.ARRAY_FLOAT
+]);
+const PRIMITIVE_DATA_TYPES_AND_HIERARCHY = /* @__PURE__ */ new Set([
+  ...PRIMITIVE_DATA_TYPES,
+  DATASET_FIELD_TYPES.HIERARCHY
+]);
+const PRIMITIVE_DATA_TYPES_AND_MARKUP = /* @__PURE__ */ new Set([
+  ...PRIMITIVE_DATA_TYPES,
+  DATASET_FIELD_TYPES.MARKUP
+]);
+const DEFAULT_PAGE_ROWS_LIMIT = 100;
+const DEFAULT_FLAT_TABLE_EXTRA_SETTINGS = {
+  pagination: "on",
+  limit: DEFAULT_PAGE_ROWS_LIMIT
+};
+const DEFAULT_DONUT_EXTRA_SETTINGS = {
+  totals: "on"
+};
+const DEFAULT_BAR_EXTRA_SETTINGS = {
+  labelsPosition: LabelsPositions.Outside
+};
+const AREA_OR_AREA100P = /* @__PURE__ */ new Set(["area", "area100p"]);
+const DEFAULT_DATE_FORMAT = "DD.MM.YYYY";
+const DEFAULT_DATETIME_FORMAT = "DD.MM.YYYY HH:mm:ss";
+const WIZARD_DATASET_ID_PARAMETER_KEY = "__datasetId";
+const DL_ADAPTIVE_TABS_BREAK_POINT_CONFIG = {
+  "400": 33,
+  "500": 30,
+  "700": 27,
+  "800": 26,
+  "900": 25,
+  "1000": 24,
+  "1100": 23,
+  "1200": 22,
+  "1300": 21,
+  "1400": 20
+};
+const MOD_KEY = "MOD";
+const UNDO_HOTKEY = [MOD_KEY, "z"];
+const REDO_HOTKEY = [MOD_KEY, "shift", "z"];
+const HOTKEYS_SCOPES = {
+  DATASETS: "datasets",
+  GLOBAL: "global",
+  WIZARD: "wizard",
+  QL: "ql",
+  DASH: "dash"
+};
+function onTableDimensionsChange({
+  visualization,
+  sort,
+  colors
+}) {
+  let invalidIndex = 0;
+  while (
+    // eslint-disable-next-line
+    sort.some((sortItem, i) => {
+      if (!visualization.checkAllowedSort(sortItem, visualization, colors)) {
+        invalidIndex = i;
+        return true;
+      }
+      return false;
+    })
+  ) {
+    sort.splice(invalidIndex, 1);
+  }
+}
+const FLAT_TABLE_VISUALIZATION = {
+  id: "flatTable",
+  type: "table",
+  name: "label_visualization-flat-table",
+  iconProps: { id: "visFlatTable", width: "24" },
+  allowFilters: true,
+  allowColors: true,
+  allowSort: true,
+  checkAllowedSort: () => {
+    return true;
+  },
+  checkAllowedDesignItems: ({ item }) => {
+    return item.type === "MEASURE";
+  },
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.ALL,
+      id: "flat-table-columns",
+      type: "flat-table-columns",
+      title: "section_columns",
+      iconProps: { data: LayoutColumns3 },
+      items: [],
+      onChange: onTableDimensionsChange,
+      required: true,
+      settings: {
+        groupping: "on"
+      }
+    }
+  ]
+};
+const prepareFieldToMeasureTransformation = (item) => {
+  if (ITEM_TYPES.MEASURES_AND_PSEUDO.has(item.type) || isParameter(item)) {
+    return item;
+  }
+  const commonDataType = getCommonDataType$1(item.data_type);
+  return {
+    ...item,
+    transformed: true,
+    fakeTitle: item.fakeTitle || item.title,
+    aggregation: commonDataType === "number" ? DatasetFieldAggregation.Sum : DatasetFieldAggregation.Countunique
+  };
+};
+function getAvailableVisualizations(options) {
+  const { yandexMap: { enabled: isYandexMapEnabled = false } = {} } = DL.CHARTKIT_SETTINGS;
+  const items = [
+    LINE_VISUALIZATION,
+    AREA_VISUALIZATION,
+    AREA_100P_VISUALIZATION,
+    COLUMN_VISUALIZATION,
+    COLUMN_100P_VISUALIZATION,
+    BAR_VISUALIZATION,
+    BAR_100P_VISUALIZATION,
+    SCATTER_VISUALIZATION,
+    PIE_VISUALIZATION,
+    DONUT_VISUALIZATION,
+    METRIC_VISUALIZATION,
+    TREEMAP_VISUALIZATION,
+    FLAT_TABLE_VISUALIZATION,
+    PIVOT_TABLE_VISUALIZATION
+  ];
+  if (isYandexMapEnabled) {
+    items.push(
+      GEOPOINT_VISUALIZATION,
+      GEOPOINT_WITH_CLUSTER_VISUALIZATION,
+      GEOPOLYGON_VISUALIZATION,
+      HEATMAP_VISUALIZATION,
+      GEOLAYER_VISUALIZATION,
+      POLYLINE_VISUALIZATION
+    );
+  }
+  items.push(COMBINED_CHART_VISUALIZATION);
+  return _.cloneDeep(items);
+}
+function getDefaultVisualization() {
+  return _.cloneDeep(COLUMN_VISUALIZATION);
+}
+function onPivotTableMeasuresChange({ visualization }) {
+  const rowsPlaceholder = visualization.placeholders.find(
+    ({ id }) => id === PlaceholderId.PivotTableRows
+  );
+  const columnsPlaceholder = visualization.placeholders.find(
+    ({ id }) => id === PlaceholderId.PivotTableColumns
+  );
+  if (!rowsPlaceholder || !columnsPlaceholder) {
+    return;
+  }
+  const columns = columnsPlaceholder.items;
+  const rows = rowsPlaceholder.items;
+  const measuresPlaceholder = visualization.placeholders.find(
+    ({ id }) => id === PlaceholderId.Measures
+  );
+  if (!measuresPlaceholder) {
+    return;
+  }
+  const isMeasureNameExist = columns.some(isMeasureNameOrValue) || rows.some(isMeasureNameOrValue);
+  const shouldUseMeasureName = measuresPlaceholder.items.length > 1;
+  if (!isMeasureNameExist && shouldUseMeasureName) {
+    if (columns.length && !rows.length) {
+      rows.push(createMeasureNames());
+    } else {
+      columns.push(createMeasureNames());
+    }
+    return;
+  }
+  if (!measuresPlaceholder.items.length && isMeasureNameExist) {
+    columnsPlaceholder.items = columns.filter((item) => !isMeasureName(item));
+    rowsPlaceholder.items = rows.filter((item) => !isMeasureName(item));
+  }
+}
+const PIVOT_TABLE_VISUALIZATION = {
+  id: "pivotTable",
+  type: "table",
+  name: "label_visualization-pivot-table",
+  iconProps: { id: "visPivot", width: "24" },
+  allowFilters: true,
+  allowColors: true,
+  allowSort: true,
+  checkAllowedSort: (item, visualization) => {
+    return visualization.placeholders.reduce((a, b2) => a.concat(b2.items), []).some((selectedItem) => selectedItem.guid === item.guid);
+  },
+  checkAllowedDesignItems: ({ item }) => {
+    return item.type === "MEASURE";
+  },
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_PSEUDO,
+      allowedDataTypes: /* @__PURE__ */ new Set([...PRIMITIVE_DATA_TYPES, "markup"]),
+      id: PlaceholderId.PivotTableColumns,
+      type: "pivot-table-columns",
+      title: "section_columns",
+      iconProps: { data: LayoutColumns3 },
+      items: [],
+      onChange: onTableDimensionsChange
+    },
+    {
+      allowedTypes: void 0,
+      allowedDataTypes: /* @__PURE__ */ new Set([...PRIMITIVE_DATA_TYPES, "markup"]),
+      id: PlaceholderId.PivotTableRows,
+      type: "rows",
+      title: "section_rows",
+      iconProps: { data: LayoutRows3 },
+      items: [],
+      onChange: onTableDimensionsChange
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      id: PlaceholderId.Measures,
+      type: "measures",
+      title: "section_measures",
+      iconProps: { data: SquareHashtag },
+      items: [],
+      onChange: onPivotTableMeasuresChange,
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const GEOPOINT_VISUALIZATION = {
+  id: "geopoint",
+  type: "geo",
+  name: "label_visualization-geopoint",
+  iconProps: { id: "visGeopoint", width: "24" },
+  allowTooltips: true,
+  allowColors: true,
+  allowFilters: true,
+  allowLayerFilters: true,
+  allowLabels: true,
+  hidden: true,
+  checkAllowedTooltips: (item) => item.type === "MEASURE" || item.type === "DIMENSION",
+  checkAllowedDesignItems: ({ item }) => item.type === "MEASURE" || item.type === "DIMENSION",
+  checkAllowedLabels: (item) => (ITEM_TYPES.DIMENSIONS_AND_MEASURES.has(item.type) || isMeasureValue(item)) && !isMarkupField(item),
+  availableLabelModes: ["absolute"],
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS,
+      allowedDataTypes: /* @__PURE__ */ new Set(["geopoint"]),
+      id: "geopoint",
+      type: "geopoint",
+      title: "section_geopoint",
+      iconProps: { data: GeoDots },
+      items: [],
+      required: true
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "size",
+      type: "measures",
+      title: "section_points_size",
+      iconProps: { data: ChevronsExpandUpRight },
+      items: [],
+      capacity: 1,
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const GEOPOINT_WITH_CLUSTER_VISUALIZATION = {
+  ...cloneDeep(GEOPOINT_VISUALIZATION),
+  id: "geopoint-with-cluster",
+  name: "label_visualization-geopoint-with-cluster",
+  checkAllowedDesignItems: ({ item }) => item.type === "DIMENSION"
+};
+const DEFAULT_BORDERS = "show";
+const DEFAULT_THRESHOLDS_MODE = "auto";
+const DEFAULT_GRADIENT_MODE = GradientType.TWO_POINT;
+getAvailableClientPalettesMap();
+const DEFAULT_TWO_POINT_GRADIENT = selectDefaultClientGradient(DEFAULT_GRADIENT_MODE);
+const DEFAULT_PALETTE_STATE = {
+  mountedColors: {},
+  palette: "",
+  selectedValue: null,
+  polygonBorders: DEFAULT_BORDERS
+};
+const DEFAULT_GRADIENT_STATE = {
+  reversed: false,
+  gradientMode: DEFAULT_GRADIENT_MODE,
+  polygonBorders: DEFAULT_BORDERS,
+  thresholdsMode: DEFAULT_THRESHOLDS_MODE,
+  leftThreshold: void 0,
+  middleThreshold: void 0,
+  rightThreshold: void 0,
+  gradientPalette: DEFAULT_TWO_POINT_GRADIENT,
+  nullMode: void 0
+};
+const ALLOWED_FOR_NULL_MODE_VISUALIZATIONS = [
+  WizardVisualizationId.FlatTable,
+  WizardVisualizationId.PivotTable
+];
+const NULLS_OPTIONS = [
+  { value: GradientNullModes.Ignore, content: i18n$5("wizard", "label_painting-ignore") },
+  { value: GradientNullModes.AsZero, content: i18n$5("wizard", "label_painting-as-0") }
+];
+const VISUALIZATION_FIELDS_KEYS = [
+  "shapes",
+  "shapesConfig",
+  "colorsConfig",
+  "colors",
+  "labels",
+  "sort"
+];
+function prepareShapes(visualization, shapes) {
+  if (visualization?.allowShapes) {
+    return {
+      shapes: shapes.filter((item) => {
+        if (item.type === "PSEUDO" || isParameter(item)) {
+          return true;
+        }
+        return visualization?.checkAllowedShapes?.({
+          item,
+          visualization,
+          designItems: shapes
+        });
+      })
+    };
+  } else {
+    return {
+      shapes: [],
+      shapesConfig: {}
+    };
+  }
+}
+function prepareColors(visualization, colors, colorsConfig) {
+  const isPieOrDonut = [WizardVisualizationId.Donut, WizardVisualizationId.Pie].includes(
+    visualization?.id
+  );
+  if (visualization?.allowColors || isPieOrDonut) {
+    const updatedColors = colors.filter((item) => {
+      if (item.type === "PSEUDO" || isParameter(item)) {
+        return true;
+      }
+      return visualization?.checkAllowedDesignItems?.({
+        item,
+        visualization,
+        designItems: colors
+      });
+    });
+    const updatedColorsConfig = ALLOWED_FOR_NULL_MODE_VISUALIZATIONS.includes(visualization?.id) ? colorsConfig : omit(colorsConfig, "nullMode");
+    return {
+      colors: updatedColors,
+      colorsConfig: updatedColorsConfig
+    };
+  } else {
+    return {
+      colors: [],
+      colorsConfig: {}
+    };
+  }
+}
+function prepareSort(visualization, sort, colors, segments, options) {
+  if (options.isCombinedChart) {
+    return { sort: [...sort] };
+  }
+  if (visualization?.allowSort) {
+    return {
+      sort: sort.filter((item) => {
+        if (isParameter(item)) {
+          return true;
+        }
+        return visualization?.checkAllowedSort(
+          item,
+          visualization,
+          colors,
+          segments
+        );
+      })
+    };
+  } else {
+    return {
+      sort: []
+    };
+  }
+}
+function prepareLabels(visualization, labels) {
+  if (visualization?.allowLabels) {
+    const { availableLabelModes = [] } = visualization;
+    return {
+      labels: labels.map((label) => {
+        if (!availableLabelModes.includes(label.mode)) {
+          return {
+            ...label,
+            mode: availableLabelModes[0]
+          };
+        }
+        return label;
+      })
+    };
+  } else {
+    return {
+      labels: []
+    };
+  }
+}
+function prepareSegments(visualization, segments, options) {
+  if (visualization.allowSegments && !options.isLayer) {
+    return {
+      segments
+    };
+  }
+  return {
+    segments: []
+  };
+}
+function prepareVisualizationItems(items, currentVisualization, options) {
+  if (!currentVisualization) {
+    return items;
+  }
+  const preparedShapes = items.shapes ? prepareShapes(currentVisualization, items.shapes) : void 0;
+  const preparedColors = prepareColors(currentVisualization, items.colors, items.colorsConfig);
+  const preparedLabels = prepareLabels(currentVisualization, items.labels);
+  const preparedSegments = prepareSegments(currentVisualization, items.segments, options);
+  const preparedSort = prepareSort(
+    currentVisualization,
+    items.sort,
+    preparedColors.colors,
+    preparedSegments.segments,
+    options
+  );
+  return {
+    ...items,
+    ...preparedShapes,
+    ...preparedColors,
+    ...preparedSort,
+    ...preparedLabels,
+    ...preparedSegments
+  };
+}
+function prepareCommonPlaceholderItems(layer, options) {
+  const commonPlaceholders = layer.commonPlaceholders || {};
+  const commonPlaceholdersItems = pick(
+    commonPlaceholders,
+    VISUALIZATION_FIELDS_KEYS
+  );
+  const updatedCommonPlaceholdersItems = prepareVisualizationItems(
+    commonPlaceholdersItems,
+    layer,
+    options
+  );
+  return {
+    ...commonPlaceholders,
+    ...updatedCommonPlaceholdersItems
+  };
+}
+function clearUnusedVisualizationItems({
+  visualization,
+  items
+}) {
+  const options = {
+    isLayer: false,
+    isCombinedChart: visualization.id === WizardVisualizationId.CombinedChart
+  };
+  let currentVisualization;
+  if (isVisualizationWithLayers(visualization)) {
+    currentVisualization = getSelectedLayer(visualization);
+    const layers = visualization.layers;
+    visualization.layers = layers.map((layer) => ({
+      ...layer,
+      commonPlaceholders: prepareCommonPlaceholderItems(layer, options)
+    }));
+    options.isLayer = true;
+  } else {
+    currentVisualization = visualization;
+  }
+  return prepareVisualizationItems(items, currentVisualization, options);
+}
+const getMergedPlaceholdersSettings = ({
+  oldSettings,
+  currentSettings,
+  keysToMerge
+}) => {
+  return keysToMerge.reduce(
+    (acc, key) => {
+      if (typeof currentSettings[key] !== "undefined") {
+        return { ...acc, [key]: oldSettings[key] };
+      }
+      return acc;
+    },
+    {}
+  );
+};
+const getChangedPlaceholderSettings = ({
+  presetSettings,
+  oldSettings
+}) => {
+  return Object.keys(presetSettings).reduce((acc, key) => {
+    const oldSetting = oldSettings[key];
+    const defaultSetting = presetSettings[key];
+    if (defaultSetting !== oldSetting) {
+      return [...acc, key];
+    }
+    return acc;
+  }, []);
+};
+const getPlaceholdersWithMergedSettings = (args) => {
+  const { oldPlaceholders, newPlaceholders, oldVisualizationId, selectedPlaceholders } = args;
+  const availableVisualizations = getAvailableVisualizations();
+  const visualizationPreset = availableVisualizations.find(({ id }) => id === oldVisualizationId);
+  if (!visualizationPreset) {
+    return newPlaceholders;
+  }
+  const presetPlaceholders = visualizationPreset.placeholders || [];
+  const changedSettingsPerPlaceholder = oldPlaceholders.map((oldPlaceholder) => {
+    if (selectedPlaceholders && !selectedPlaceholders[oldPlaceholder.id]) {
+      return [];
+    }
+    const currentPresetPlaceholder = presetPlaceholders.find(
+      (presetPlaceholder) => presetPlaceholder.id === oldPlaceholder.id
+    );
+    const oldSettings = oldPlaceholder.settings || {};
+    const presetSettings = currentPresetPlaceholder?.settings || {};
+    return getChangedPlaceholderSettings({ oldSettings, presetSettings });
+  });
+  return newPlaceholders.map((placeholder, index) => {
+    if (selectedPlaceholders && !selectedPlaceholders[placeholder.id]) {
+      return placeholder;
+    }
+    const changedSettingsInPrevVisualization = changedSettingsPerPlaceholder[index];
+    const oldPlaceholder = oldPlaceholders[index];
+    let mergedSettings = {};
+    const currentSettings = placeholder.settings || {};
+    if (oldPlaceholder) {
+      const oldSettings = oldPlaceholder.settings || {};
+      mergedSettings = getMergedPlaceholdersSettings({
+        oldSettings,
+        currentSettings,
+        keysToMerge: changedSettingsInPrevVisualization
+      });
+    }
+    return {
+      ...placeholder,
+      settings: {
+        ...currentSettings,
+        ...mergedSettings
+      }
+    };
+  });
+};
+const getChartFiltersWithDisabledProp = ({
+  dashboardFilters,
+  chartFilters
+}) => {
+  const filtersFieldsMap = dashboardFilters.reduce(
+    (acc, dashboardFilter) => {
+      acc[dashboardFilter.guid] = true;
+      return acc;
+    },
+    {}
+  );
+  return chartFilters.map((chartFilter) => {
+    if (filtersFieldsMap[chartFilter.guid]) {
+      return {
+        ...chartFilter,
+        disabled: i18n$5("wizard", "tooltip_filter_item")
+      };
+    }
+    return chartFilter;
+  });
+};
+const i18n$1 = I18n.keyset("wizard");
+const getVisualizationConfig = (type) => {
+  let visualization;
+  switch (type) {
+    case "geopoint": {
+      visualization = _.cloneDeep(GEOPOINT_VISUALIZATION);
+      visualization.allowLayerFilters = true;
+      break;
+    }
+    case "geopolygon": {
+      visualization = _.cloneDeep(GEOPOLYGON_VISUALIZATION);
+      visualization.allowLayerFilters = true;
+      break;
+    }
+    case "heatmap": {
+      visualization = _.cloneDeep(HEATMAP_VISUALIZATION);
+      visualization.allowLayerFilters = true;
+      break;
+    }
+    case "polyline": {
+      visualization = _.cloneDeep(POLYLINE_VISUALIZATION);
+      visualization.allowLayerFilters = true;
+      break;
+    }
+    case "geopoint-with-cluster": {
+      visualization = _.cloneDeep(GEOPOINT_WITH_CLUSTER_VISUALIZATION);
+      visualization.allowLayerFilters = true;
+      break;
+    }
+    case "line": {
+      visualization = _.cloneDeep(LINE_VISUALIZATION);
+      visualization.placeholders[0].capacity = 2;
+      break;
+    }
+    case "column": {
+      visualization = _.cloneDeep(COLUMN_VISUALIZATION);
+      visualization.placeholders[0].capacity = 2;
+      break;
+    }
+    case "area": {
+      visualization = _.cloneDeep(AREA_VISUALIZATION);
+      visualization.placeholders[0].capacity = 2;
+      break;
+    }
+  }
+  return visualization;
+};
+const getDefaultCommonPlaceholders = () => ({
+  commonPlaceholders: {
+    colors: [],
+    colorsConfig: {},
+    filters: [],
+    geopointsConfig: {},
+    sort: [],
+    labels: [],
+    tooltips: [],
+    shapes: [],
+    shapesConfig: {}
+  }
+});
+const getDefaultGeolayerSettings = (type, layersNames = {}) => {
+  let index = 1;
+  let name;
+  do {
+    name = `${i18n$1("label_new-layer")} ${index}`;
+    index = index + 1;
+  } while (layersNames[name]);
+  return {
+    layerSettings: {
+      type,
+      id: v1(),
+      name,
+      alpha: 80,
+      valid: false
+    }
+  };
+};
+const createVisualizationLayer = (type, layersNames) => {
+  return {
+    ...getVisualizationConfig(type),
+    ...getDefaultCommonPlaceholders(),
+    ...getDefaultGeolayerSettings(type, layersNames)
+  };
+};
+const updateVisualizationLayerType = (layer, newType) => {
+  const transition = `${layer.layerSettings.type}-${newType}`;
+  const config = getVisualizationConfig(newType);
+  const layerSettings = { ...layer.layerSettings };
+  const commonPlaceholders = { ...layer.commonPlaceholders };
+  layerSettings.type = newType;
+  if ([
+    "geopoint-heatmap",
+    "heatmap-geopoint",
+    "geopoint-geopoint-with-cluster",
+    "geopoint-with-cluster-geopoint",
+    "heatmap-geopoint-with-cluster",
+    "geopoint-with-cluster-heatmap"
+  ].includes(transition)) {
+    config.placeholders[0].items = [...layer.placeholders[0].items];
+  }
+  if (["line", "area", "column"].includes(newType)) {
+    config.placeholders = getPlaceholdersWithMergedSettings({
+      oldPlaceholders: layer.placeholders || [],
+      newPlaceholders: config.placeholders || [],
+      oldVisualizationId: layer.id,
+      selectedPlaceholders: { x: true }
+    });
+    config.placeholders[0].items = [...layer.placeholders[0].items];
+    config.placeholders[1].items = [...layer.placeholders[1].items];
+  }
+  return {
+    ...config,
+    layerSettings,
+    commonPlaceholders
+  };
+};
+const convertVisualizationToGeolayer = (visualization) => {
+  const type = visualization.id;
+  const config = getVisualizationConfig(type);
+  return {
+    ...config,
+    ...visualization,
+    ...getDefaultCommonPlaceholders(),
+    ...getDefaultGeolayerSettings(type)
+  };
+};
+const getUpdatedLayers = (layers, updatedLayer) => {
+  const newLayers = layers.filter(
+    (layer) => layer.layerSettings.id !== updatedLayer.layerSettings.id
+  );
+  switch (updatedLayer.layerSettings.type) {
+    case "geopolygon": {
+      const index = layers.findIndex((layer) => layer.layerSettings.type === "geopoint");
+      if (index === -1) {
+        newLayers.push(updatedLayer);
+      } else {
+        newLayers.splice(index, 0, updatedLayer);
+      }
+      break;
+    }
+    case "heatmap": {
+      let index = layers.findIndex((layer) => layer.layerSettings.type === "geopolygon");
+      if (index !== -1) {
+        newLayers.splice(index, 0, updatedLayer);
+        break;
+      }
+      index = layers.findIndex((layer) => layer.layerSettings.type === "geopoint");
+      if (index === -1) {
+        newLayers.push(updatedLayer);
+      } else {
+        newLayers.splice(index === 0 ? 0 : index - 1, 0, updatedLayer);
+      }
+      break;
+    }
+    case "polyline": {
+      const index = layers.findIndex((layer) => layer.layerSettings.type === "geopoint");
+      if (index === -1) {
+        newLayers.push(updatedLayer);
+      } else {
+        newLayers.splice(index, 0, updatedLayer);
+      }
+      break;
+    }
+    default: {
+      newLayers.push(updatedLayer);
+      break;
+    }
+  }
+  return newLayers;
+};
+function getParametersFields(parametersParamsPairs, dimensions) {
+  return parametersParamsPairs.reduce((acc, paramPair) => {
+    const [key, value = ""] = paramPair;
+    if (value.trim() === "") {
+      return acc;
+    }
+    const parsedParameterValue = String(value);
+    if (!parsedParameterValue) {
+      return acc;
+    }
+    const foundItem = [...dimensions].find((item) => {
+      return item.guid === key || item.title === key ? item : null;
+    });
+    if (!foundItem) {
+      return acc;
+    }
+    const parameterFromDashboard = {
+      ...foundItem,
+      unsaved: true,
+      default_value: parsedParameterValue
+    };
+    return [...acc, parameterFromDashboard];
+  }, []);
+}
+const findFieldInDatasetSection = ({
+  datasetSectionFields,
+  guidOrTitle
+}) => {
+  return datasetSectionFields.find((field) => {
+    return field.guid === guidOrTitle || (field.fakeTitle || field.title) === guidOrTitle;
+  });
+};
+function getFiltersFields(paramsPairs, filters, fields) {
+  const filtersFields = [];
+  const groupedParams = paramsPairs.reduce((acc, paramPair) => {
+    const key = paramPair[0];
+    const urlValue = paramPair[1];
+    if (!(key in acc)) {
+      acc[key] = [];
+    }
+    acc[key].push(urlValue);
+    return acc;
+  }, {});
+  Object.entries(groupedParams).forEach(([key, values]) => {
+    const foundItem = findFieldInDatasetSection({
+      datasetSectionFields: fields,
+      guidOrTitle: key
+    });
+    if (!foundItem) {
+      return;
+    }
+    const isFilterAlreadyInChart = filters.find((filter) => filter.guid === foundItem.guid);
+    const defaultOperation = isDateField(foundItem) && values.length === 1 ? Operations.EQ : void 0;
+    values.forEach((urlValue) => {
+      if (!urlValue && isFilterAlreadyInChart) {
+        filtersFields.push({
+          ...foundItem,
+          unsaved: true,
+          filter: {
+            operation: { code: Operations.NO_SELECTED_VALUES },
+            value: [""]
+          }
+        });
+      } else if (urlValue === "") {
+        return;
+      }
+      const parsedFiltersOperation = resolveOperation(urlValue, defaultOperation);
+      if (!parsedFiltersOperation) {
+        return;
+      }
+      const code = parsedFiltersOperation.operation;
+      const value = [parsedFiltersOperation.value];
+      const foundFilter = filtersFields.find((item) => {
+        return item.guid === key || item.title === key;
+      });
+      if (foundFilter && (code === Operations.IN || code === Operations.NIN)) {
+        foundFilter.filter.value = [...foundFilter.filter.value, ...value];
+      } else {
+        filtersFields.push({
+          ...foundItem,
+          unsaved: true,
+          filter: {
+            operation: {
+              code
+            },
+            value
+          }
+        });
+      }
+    });
+  });
+  const chartFilters = getChartFiltersWithDisabledProp({
+    dashboardFilters: filtersFields,
+    chartFilters: filters
+  });
+  return { filtersFields, chartFilters };
+}
+function getDefaultVisualisationExtraSettings(visualisationId) {
+  switch (visualisationId) {
+    case VISUALIZATION_IDS.FLAT_TABLE:
+      return DEFAULT_FLAT_TABLE_EXTRA_SETTINGS;
+    case VISUALIZATION_IDS.DONUT:
+      return DEFAULT_DONUT_EXTRA_SETTINGS;
+    case VISUALIZATION_IDS.COLUMN:
+    case VISUALIZATION_IDS.BAR:
+      return DEFAULT_BAR_EXTRA_SETTINGS;
+    default:
+      return null;
+  }
+}
+const getDefaultExtraSettings = (visualisationId, prevExtraSettings) => {
+  let defaultExtraSettings = getDefaultVisualisationExtraSettings(visualisationId) || {};
+  if (prevExtraSettings) {
+    const navigatorSettings = prevExtraSettings.navigatorSettings;
+    const navigatorMode = prevExtraSettings.navigatorMode;
+    if (navigatorSettings && navigatorSettings.navigatorMode === NavigatorModes.Show) {
+      defaultExtraSettings = {
+        ...defaultExtraSettings,
+        navigatorSettings
+      };
+    } else if (navigatorMode && navigatorMode === NavigatorModes.Show) {
+      defaultExtraSettings = {
+        ...defaultExtraSettings,
+        navigatorMode,
+        navigatorSeriesName: prevExtraSettings?.navigatorSeriesName
+      };
+    }
+  }
+  return defaultExtraSettings;
+};
+const isFieldVisible = (field) => !(field.quickFormula || field.hidden || field.virtual);
+const getFieldFormat = (field) => {
+  let format = field.format;
+  if (!format) {
+    format = field.data_type === DATASET_FIELD_TYPES.DATE ? DEFAULT_DATE_FORMAT : DEFAULT_DATETIME_FORMAT;
+  }
+  return format;
+};
+function resolveDateValue(value) {
+  if (/^__relative/.test(value)) {
+    return [resolveRelativeDate(value)];
+  }
+  if (/^__interval/.test(value)) {
+    const resolvedValue = resolveIntervalDate(value);
+    return [resolvedValue?.from, resolvedValue?.to];
+  }
+  return null;
+}
+const parseFilterDate = (item) => {
+  const { filter } = item;
+  const format = getFieldFormat(item);
+  const dateValue = filter?.value[0];
+  if (!dateValue) {
+    return "";
+  }
+  const resolved = resolveDateValue(dateValue);
+  if (!resolved) {
+    return moment(dateValue).utc().format(format);
+  }
+  const [from, to] = resolved;
+  if (filter.operation.code === Operations.BETWEEN) {
+    return `${moment(from).utc().format(format)}-${moment(to).utc().format(format)}`;
+  }
+  return moment(from).utc().format(format);
+};
+const parseParameterDefaultValue = (item) => {
+  const format = getFieldFormat(item);
+  const defaultValue = String(item.default_value);
+  if (isDateField(item)) {
+    const resolved = resolveDateValue(defaultValue);
+    if (resolved) {
+      return resolved.map((dateValue) => moment(dateValue).format(format)).join("-");
+    }
+  }
+  return defaultValue;
+};
+const removeUrlParameters = (keys) => {
+  const router = getRouter();
+  const search = router.location().params();
+  if (!keys.length || !keys.some((key) => search.has(key))) return;
+  keys.forEach((key) => search.delete(key));
+  router.replace({ search });
+};
+const updateUrlParameter = ({ key, value }) => {
+  const router = getRouter();
+  const search = router.location().params();
+  search.set(key, value);
+  router.replace({ search });
+};
+const getExistedParameterKeys = (args) => {
+  const searchParams = getLocation().params();
+  return args.possibleKeys.filter((key) => searchParams.get(key) !== null);
+};
+const appendUrlParameters = ({ key, values }) => {
+  const router = getRouter();
+  const search = router.location().params();
+  values.forEach((value) => search.append(key, value));
+  router.replace({ search });
+};
+const validateThresholds = (args) => {
+  const { pointsToValidate, leftThreshold, middleThreshold, rightThreshold } = args;
+  const left = Number(leftThreshold);
+  const middle = Number(middleThreshold);
+  const right = Number(rightThreshold);
+  const typeLeft = typeof left !== "number" || isNaN(left);
+  const typeRight = typeof right !== "number" || isNaN(right);
+  const typeMiddle = typeof middle !== "number" || isNaN(middle);
+  let result;
+  if (pointsToValidate === "2-point") {
+    if (typeLeft || typeRight) {
+      result = {};
+      if (typeLeft) {
+        result.left = { text: i18n$1("label_enter-number") };
+      }
+      if (typeRight) {
+        result.right = { text: i18n$1("label_enter-number") };
+      }
+      return result;
+    }
+    if (left > right) {
+      result = {
+        left: {
+          text: i18n$1("label_should-be-less-than-right")
+        }
+      };
+    }
+    return result;
+  } else {
+    if (typeLeft || typeMiddle || typeRight) {
+      result = {};
+      if (typeLeft) {
+        result.left = { text: i18n$1("label_enter-number") };
+      }
+      if (typeMiddle) {
+        result.middle = { text: i18n$1("label_enter-number") };
+      }
+      if (typeRight) {
+        result.right = { text: i18n$1("label_enter-number") };
+      }
+      return result;
+    }
+    if (left > right) {
+      result = {};
+      result.left = {
+        text: i18n$1("label_should-be-less-than-right")
+      };
+    }
+    if (middle > right) {
+      result = result || {};
+      result.middle = {
+        text: i18n$1("label_should-be-less-than-right")
+      };
+    }
+    if (left > middle) {
+      result = result || {};
+      result.left = {
+        text: i18n$1("label_should-be-less-than-middle")
+      };
+    }
+    return result;
+  }
+};
+const GEOLAYER_VISUALIZATION = {
+  id: "geolayer",
+  type: "geo",
+  name: "label_visualization-geolayer",
+  iconProps: { id: "visGeolayers", width: "24" },
+  layers: [
+    createVisualizationLayer(
+      "geopoint"
+    )
+  ],
+  // by default, we add one layer with dots
+  selectedLayerId: "",
+  placeholders: []
+};
+const HEATMAP_VISUALIZATION = {
+  id: "heatmap",
+  type: "geo",
+  name: "label_visualization-heatmap",
+  iconProps: { id: "visHeatmap", width: "24" },
+  allowColors: true,
+  allowFilters: true,
+  allowLayerFilters: true,
+  hidden: true,
+  checkAllowedDesignItems: ({ item }) => {
+    return item.type === "MEASURE" || item.cast === "geopoint" || item.data_type === "geopoint";
+  },
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS,
+      allowedDataTypes: /* @__PURE__ */ new Set(["geopoint"]),
+      id: "heatmap",
+      type: "geopoint",
+      title: "section_geopoint",
+      iconProps: { data: GeoDots },
+      items: [],
+      required: true
+    }
+  ]
+};
+const GEOPOLYGON_VISUALIZATION = {
+  id: "geopolygon",
+  type: "geo",
+  name: "label_visualization-geopolygon",
+  iconProps: { id: "visGeopolygon", width: "24" },
+  allowTooltips: true,
+  allowColors: true,
+  allowFilters: true,
+  allowLayerFilters: true,
+  hidden: true,
+  checkAllowedTooltips: (item) => item.type === "MEASURE" || item.type === "DIMENSION",
+  checkAllowedDesignItems: ({ item }) => item.type === "MEASURE" || item.type === "DIMENSION",
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS,
+      allowedDataTypes: /* @__PURE__ */ new Set(["geopolygon"]),
+      id: "geopolygon",
+      type: "geopolygon",
+      title: "section_geopolygon",
+      iconProps: { data: GeoPolygons },
+      items: [],
+      required: true
+    }
+  ]
+};
+const POLYLINE_VISUALIZATION = {
+  id: "polyline",
+  type: "geo",
+  name: "label_visualization-polyline",
+  iconProps: { id: "visGeopoint", width: "24" },
+  allowTooltips: false,
+  allowColors: true,
+  allowFilters: true,
+  allowLayerFilters: true,
+  allowLabels: false,
+  allowSort: true,
+  checkAllowedSort: () => true,
+  hidden: true,
+  checkAllowedTooltips: (item) => item.type === DatasetFieldType.Measure || item.type === DatasetFieldType.Dimension,
+  checkAllowedDesignItems: ({ item }) => item.type === DatasetFieldType.Dimension || item.type === DatasetFieldType.Measure,
+  checkAllowedLabels: (item) => (ITEM_TYPES.DIMENSIONS_AND_MEASURES.has(item.type) || isMeasureValue(item)) && !isMarkupField(item),
+  availableLabelModes: ["absolute"],
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS,
+      allowedDataTypes: /* @__PURE__ */ new Set(["geopoint"]),
+      id: "polyline",
+      type: "polyline",
+      title: "section_polyline",
+      iconProps: { data: GeoDots },
+      items: [],
+      required: true,
+      settings: {
+        polylinePoints: "off"
+      }
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      id: "measures",
+      type: "measures",
+      title: "section_measures",
+      iconProps: { data: SquareHashtag },
+      items: [],
+      transform: prepareFieldToMeasureTransformation
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "grouping",
+      type: "grouping",
+      title: "section_grouping",
+      iconProps: { data: LayoutColumns3 },
+      items: []
+    }
+  ]
+};
+const prepareFieldToDimensionTransformation = (item) => {
+  if (ITEM_TYPES.DIMENSIONS_AND_PSEUDO.has(item.type) || isFieldHierarchy(item)) {
+    return item;
+  }
+  return {
+    ...item,
+    transformed: true,
+    fakeTitle: item.fakeTitle || item.title,
+    aggregation: DatasetFieldAggregation.None
+  };
+};
+const PIE_VISUALIZATION = {
+  id: WizardVisualizationId.Pie,
+  type: "pie",
+  name: "label_visualization-pie",
+  iconProps: { id: "visPie", width: "24" },
+  allowFilters: true,
+  allowLabels: true,
+  allowSort: true,
+  checkAllowedSort: (item, visualization) => {
+    if (item.type === "MEASURE") {
+      return true;
+    }
+    const selectedItems = visualization.placeholders.reduce(
+      (a, b2) => a.concat(b2.items),
+      []
+    );
+    return selectedItems.some((selectedItem) => selectedItem.guid === item.guid);
+  },
+  checkAllowedLabels: (item) => ITEM_TYPES.ALL.has(item.type),
+  availableLabelModes: ["absolute", "percent"],
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.DIMENSIONS,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: PlaceholderId.Dimensions,
+      type: PlaceholderId.Dimensions,
+      title: "section_categories",
+      iconProps: { data: LayoutColumns3 },
+      items: [],
+      required: false,
+      capacity: 1,
+      transform: prepareFieldToDimensionTransformation
+    },
+    {
+      allowedTypes: ITEM_TYPES.ALL,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES_AND_HIERARCHY,
+      id: PlaceholderId.Colors,
+      type: PlaceholderId.Colors,
+      title: "section_color",
+      iconProps: { data: BucketPaint },
+      items: [],
+      required: false,
+      capacity: 1
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "measures",
+      type: "measures",
+      title: "section_measures",
+      iconProps: { data: ChartPie },
+      items: [],
+      required: true,
+      capacity: 1,
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const DONUT_VISUALIZATION = {
+  ...PIE_VISUALIZATION,
+  id: WizardVisualizationId.Donut,
+  highchartsId: "pie",
+  name: "label_visualization-donut",
+  hidden: false,
+  iconProps: { id: "visDonut", width: "24" }
+};
+function onTreemapDimensionsChange({ visualization, colors }) {
+  let invalidIndex = 0;
+  while (
+    // eslint-disable-next-line
+    colors.some((sortItem, i) => {
+      if (!visualization.checkAllowedDesignItems?.({
+        item: sortItem,
+        visualization,
+        designItems: colors
+      })) {
+        invalidIndex = i;
+        return true;
+      }
+      return false;
+    })
+  ) {
+    colors.splice(invalidIndex, 1);
+  }
+}
+function onTreemapMeasuresChange({ placeholder, visualization }) {
+  const dimensions = visualization.placeholders[0].items;
+  const existingMeasureNameOrValue = dimensions.find(isMeasureNameOrValue);
+  if (placeholder.items.length > 1 && !existingMeasureNameOrValue) {
+    dimensions.push(createMeasureNames());
+  } else if (placeholder.items.length < 2) {
+    if (existingMeasureNameOrValue) {
+      dimensions.splice(dimensions.indexOf(existingMeasureNameOrValue), 1);
+    }
+  }
+}
+const TREEMAP_VISUALIZATION = {
+  id: WizardVisualizationId.Treemap,
+  type: "treemap",
+  name: "label_visualization-treemap",
+  allowFilters: true,
+  iconProps: { id: "visTreemap", width: "24" },
+  allowColors: true,
+  checkAllowedDesignItems: ({
+    item,
+    visualization
+  }) => {
+    if (item.type === "MEASURE") {
+      return true;
+    }
+    const placeholders = visualization?.placeholders || [];
+    const selectedItems = placeholders.reduce((a, b2) => a.concat(b2.items), []);
+    return selectedItems.some((selectedItem) => selectedItem.guid === item.guid);
+  },
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.ALL,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES_AND_HIERARCHY,
+      id: "dimensions",
+      type: "dimensions",
+      title: "section_dimensions",
+      iconProps: { data: GeoPolygons },
+      items: [],
+      onChange: onTreemapDimensionsChange,
+      required: true,
+      transform: prepareFieldToDimensionTransformation
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "measures",
+      type: "measures",
+      title: "section_size",
+      iconProps: { data: ChevronsExpandUpRight },
+      items: [],
+      onChange: onTreemapMeasuresChange,
+      required: true,
+      capacity: 1,
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const selectPlaceholders = (placeholders, ids) => {
+  const uniqueIds = new Set(ids);
+  return (placeholders ?? []).reduce(
+    (selectedPlaceholders, p) => {
+      const id = p.id;
+      return uniqueIds.has(id) ? Object.defineProperty(selectedPlaceholders, id, { value: p }) : selectedPlaceholders;
+    },
+    {}
+  );
+};
+const updateMultipleColors = (args) => {
+  const { colors, placeholders } = args;
+  if (colors.length <= 1) {
+    return colors;
+  }
+  const { y, y2 } = selectPlaceholders(placeholders, [PlaceholderId.Y, PlaceholderId.Y2]);
+  const yItems = y?.items || [];
+  const y2Items = y2?.items || [];
+  yItems.splice(1, yItems.length - 1);
+  y2Items.splice(1, y2Items.length - 1);
+  return colors;
+};
+const updateColors = (args) => {
+  const { colors, prevColors, placeholders, visualization, isMultipleColorsSupported } = args;
+  if (colors?.length && isMultipleColorsSupported) {
+    return updateMultipleColors({
+      colors,
+      placeholders
+    });
+  }
+  const colorsCopy = [...colors];
+  if (colors?.length === 1 && isMeasureNameOrValue(colors[0])) {
+    visualization.colorsCapacity = 2;
+  }
+  if (colors?.length === 2) {
+    const isBothFieldsPseudo = colorsCopy.every((color) => isMeasureNameOrValue(color));
+    const prevColorsGuidsMap = prevColors?.reduce(
+      (acc, color) => {
+        return {
+          ...acc,
+          [color.guid || color.title]: true
+        };
+      },
+      {}
+    );
+    const replacedItemIndex = colorsCopy.findIndex(
+      (color) => prevColorsGuidsMap[color.guid || color.title]
+    );
+    colorsCopy.splice(replacedItemIndex, 1);
+    if (!isBothFieldsPseudo) {
+      visualization.colorsCapacity = 1;
+      const yItems1 = placeholders[1].items;
+      const yItems2 = placeholders[2] ? placeholders[2].items : [];
+      yItems1.splice(1, yItems1.length - 1);
+      yItems2.splice(1, yItems2.length - 1);
+    }
+  }
+  return colorsCopy;
+};
+function linearCheckColor({
+  item,
+  visualization,
+  designItems,
+  isMultipleColorsSupported
+}) {
+  if (isMeasureField(item) || isMeasureValue(item) || item.data_type === DATASET_FIELD_TYPES.MARKUP) {
+    return false;
+  }
+  if (isMeasureNameOrValue(item)) {
+    const selectedItems = designItems;
+    if (selectedItems.length === 0) {
+      return true;
+    }
+    return selectedItems.every((selectedItem) => {
+      return !isMeasureNameOrValue(selectedItem);
+    });
+  } else {
+    const placeholders = visualization?.placeholders || [];
+    const selectedItems = placeholders.reduce(
+      (a, b2) => a.concat(b2.items),
+      []
+    );
+    if (isMultipleColorsSupported) {
+      selectedItems.push(...designItems);
+    }
+    return selectedItems.every((selectedItem) => {
+      return selectedItem.guid !== item.guid;
+    });
+  }
+}
+function lineCommonCheckColor({
+  item,
+  designItems,
+  isMultipleColorsSupported
+}) {
+  if (isMeasureName(item)) {
+    return designItems.every((selectedItem) => {
+      return !isMeasureName(selectedItem);
+    });
+  } else if (isMeasureValue(item)) {
+    return designItems.every((selectedItem) => {
+      return !isMeasureValue(selectedItem);
+    });
+  }
+  if (isMultipleColorsSupported) {
+    return designItems.every((selectedItem) => selectedItem.guid !== item.guid);
+  }
+  return true;
+}
+function onLineChartDesignItemsChange({
+  colors = [],
+  visualization,
+  prevColors = [],
+  shapes = [],
+  isMultipleColorsSupported = false
+}) {
+  const placeholders = visualization.placeholders;
+  const shapesCopy = [...shapes];
+  if (shapes?.length) {
+    if (shapes.length === 1 && isMeasureNameOrValue(shapes[0])) {
+      visualization.shapesCapacity = 2;
+    } else if (shapes.length === 2) {
+      const shapesPseudoIndex = shapesCopy.findIndex((shape) => isMeasureNameOrValue(shape));
+      shapesCopy.splice(shapesPseudoIndex, 1);
+      visualization.shapesCapacity = 1;
+      const yItems1 = placeholders[1].items;
+      const yItems2 = placeholders[2] ? placeholders[2].items : [];
+      yItems1.splice(1, yItems1.length - 1);
+      yItems2.splice(1, yItems2.length - 1);
+    }
+  }
+  return {
+    shapes: shapesCopy,
+    colors: updateColors({
+      colors,
+      prevColors,
+      placeholders,
+      visualization,
+      isMultipleColorsSupported
+    })
+  };
+}
+function linearCheckLabels(item) {
+  return ITEM_TYPES.DIMENSIONS_AND_MEASURES.has(item.type) || isMeasureValue(item);
+}
+function isMeasureFieldInColors(colors) {
+  return colors.length && isMeasureField(colors[0] || isMeasureValue(colors[0]));
+}
+function findMeasureNameOrValueFieldInSection(section) {
+  return section.find(isMeasureNameOrValue);
+}
+function onMeasureAxisChange({
+  placeholder,
+  placeholderId,
+  colors,
+  visualization,
+  shapes,
+  isQL
+}) {
+  if (isMeasureFieldInColors(colors)) {
+    return;
+  }
+  const xPlaceholder = visualization.placeholders[PlaceholderIndexes.xPlaceholder];
+  const xPlaceholderItems = xPlaceholder?.items || [];
+  const pseudoFieldInColors = findMeasureNameOrValueFieldInSection(colors);
+  const pseudoFieldInShapes = findMeasureNameOrValueFieldInSection(shapes);
+  const pseudoFieldInXSection = findMeasureNameOrValueFieldInSection(xPlaceholderItems);
+  let oppositeMeasurePlaceholderIndex;
+  let oppositeMeasurePlaceholderId;
+  switch (placeholderId) {
+    case "y":
+      oppositeMeasurePlaceholderIndex = PlaceholderIndexes.y2Placeholder;
+      oppositeMeasurePlaceholderId = PlaceholderId.Y2;
+      break;
+    case "y2":
+      oppositeMeasurePlaceholderIndex = PlaceholderIndexes.yPlaceholder;
+      oppositeMeasurePlaceholderId = PlaceholderId.Y;
+      break;
+  }
+  if (!oppositeMeasurePlaceholderIndex) {
+    return;
+  }
+  const oppositeMeasurePlaceholder = visualization.placeholders[oppositeMeasurePlaceholderIndex];
+  let totalItemsCount = placeholder.items.length;
+  if (oppositeMeasurePlaceholder && oppositeMeasurePlaceholder.id === oppositeMeasurePlaceholderId) {
+    totalItemsCount += (oppositeMeasurePlaceholder.items || []).length;
+  }
+  if (totalItemsCount > 1) {
+    if (!pseudoFieldInXSection) {
+      if (!pseudoFieldInColors) {
+        if (colors.length > 0) {
+          colors.splice(0, colors.length);
+        }
+        colors.push(createMeasureNames(isQL));
+        visualization.colorsCapacity = 2;
+      }
+      if (!pseudoFieldInShapes) {
+        if (shapes.length > 0) {
+          shapes.splice(0, shapes.length);
+        }
+        shapes.push(createMeasureNames(isQL));
+        visualization.shapesCapacity = 2;
+      }
+    }
+  } else if (totalItemsCount < 2) {
+    if (pseudoFieldInShapes || pseudoFieldInColors) {
+      if (pseudoFieldInColors) {
+        colors.splice(colors.indexOf(pseudoFieldInColors), 1);
+        visualization.colorsCapacity = 1;
+      }
+      if (pseudoFieldInShapes) {
+        shapes.splice(shapes.indexOf(pseudoFieldInShapes), 1);
+        visualization.shapesCapacity = 1;
+      }
+    }
+  } else if (pseudoFieldInXSection) {
+    xPlaceholderItems.splice(xPlaceholderItems.indexOf(pseudoFieldInXSection), 1);
+  }
+}
+const LineXPlaceholder = {
+  allowedTypes: ITEM_TYPES.ALL,
+  allowedDataTypes: PRIMITIVE_DATA_TYPES_AND_HIERARCHY,
+  id: "x",
+  type: "x",
+  title: "section_x",
+  iconProps: { data: ArrowRight },
+  items: [],
+  required: true,
+  capacity: 1,
+  settings: {
+    title: "off",
+    titleValue: "",
+    type: "linear",
+    grid: "on",
+    gridStep: "auto",
+    gridStepValue: 50,
+    hideLabels: "no",
+    labelsView: "auto",
+    holidays: "off",
+    axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+    axisLabelFormating: {},
+    axisFormatMode: "auto",
+    axisModeMap: {},
+    axisVisibility: "show"
+  },
+  transform: prepareFieldToDimensionTransformation
+};
+const LineYPlaceholder = {
+  allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+  allowedFinalTypes: ITEM_TYPES.MEASURES,
+  allowedDataTypes: PRIMITIVE_DATA_TYPES,
+  id: "y",
+  type: "y",
+  title: "section_y",
+  iconProps: { data: ArrowUp },
+  items: [],
+  onChange: onMeasureAxisChange,
+  settings: {
+    scale: "auto",
+    scaleValue: AxisAutoScaleModes.Auto,
+    title: "off",
+    titleValue: "",
+    type: "linear",
+    grid: "on",
+    gridStep: "auto",
+    gridStepValue: 50,
+    hideLabels: "no",
+    labelsView: "auto",
+    nulls: AxisNullsMode.Connect,
+    axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+    axisLabelFormating: {},
+    axisFormatMode: "auto",
+    axisVisibility: "show"
+  },
+  transform: prepareFieldToMeasureTransformation
+};
+const LINE_VISUALIZATION = {
+  id: WizardVisualizationId.Line,
+  type: "line",
+  name: "label_visualization-line",
+  iconProps: { id: "visLines", width: "24" },
+  allowFilters: true,
+  allowColors: true,
+  allowSort: true,
+  allowLabels: true,
+  allowSegments: true,
+  allowShapes: true,
+  colorsCapacity: 1,
+  shapesCapacity: 1,
+  checkAllowedSort: (item, visualization, _colors, segments) => {
+    if (item.type === "MEASURE") {
+      return true;
+    }
+    const selectedItems = visualization.placeholders.reduce((a, b2) => a.concat(b2.items), []).concat(segments || []).filter((selectedItem) => selectedItem.type === "DIMENSION");
+    return selectedItems.some((selectedItem) => selectedItem.guid === item.guid);
+  },
+  checkAllowedDesignItems: linearCheckColor,
+  checkAllowedShapes: linearCheckColor,
+  checkAllowedLabels: linearCheckLabels,
+  availableLabelModes: ["absolute"],
+  onDesignItemsChange: onLineChartDesignItemsChange,
+  placeholders: [
+    { ...LineXPlaceholder },
+    LineYPlaceholder,
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "y2",
+      type: "y2",
+      title: "section_y2",
+      iconProps: { data: ArrowUp },
+      items: [],
+      onChange: onMeasureAxisChange,
+      settings: {
+        scale: "auto",
+        scaleValue: AxisAutoScaleModes.Auto,
+        title: "off",
+        titleValue: "",
+        type: "linear",
+        grid: "on",
+        gridStep: "auto",
+        gridStepValue: 50,
+        hideLabels: "no",
+        labelsView: "auto",
+        nulls: AxisNullsMode.Connect,
+        axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+        axisLabelFormating: {},
+        axisFormatMode: "auto",
+        axisVisibility: "show"
+      },
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const AREA_VISUALIZATION = {
+  id: WizardVisualizationId.Area,
+  type: "line",
+  name: "label_visualization-area",
+  iconProps: { id: "visArea", width: "24" },
+  allowFilters: true,
+  allowColors: true,
+  allowSort: true,
+  allowSegments: true,
+  allowLabels: true,
+  checkAllowedSort: checkAllowedAreaSort,
+  checkAllowedDesignItems: linearCheckColor,
+  checkAllowedLabels: linearCheckLabels,
+  availableLabelModes: ["absolute"],
+  onDesignItemsChange: onLineChartDesignItemsChange,
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.ALL,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES_AND_HIERARCHY,
+      id: "x",
+      type: "x",
+      title: "section_x",
+      iconProps: { data: ArrowRight },
+      items: [],
+      required: true,
+      capacity: 1,
+      settings: {
+        title: "off",
+        titleValue: "",
+        type: "linear",
+        grid: "on",
+        gridStep: "auto",
+        gridStepValue: 50,
+        hideLabels: "no",
+        labelsView: "auto",
+        holidays: "off",
+        axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+        axisLabelFormating: {},
+        axisFormatMode: "auto",
+        axisModeMap: {},
+        axisVisibility: "show"
+      },
+      transform: prepareFieldToDimensionTransformation
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "y",
+      type: "y",
+      title: "section_y",
+      iconProps: { data: ArrowUp },
+      items: [],
+      onChange: onMeasureAxisChange,
+      settings: {
+        scale: "auto",
+        scaleValue: AxisAutoScaleModes.Auto,
+        title: "off",
+        titleValue: "",
+        type: "linear",
+        grid: "on",
+        gridStep: "auto",
+        gridStepValue: 50,
+        hideLabels: "no",
+        labelsView: "auto",
+        nulls: AxisNullsMode.AsZero,
+        axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+        axisLabelFormating: {},
+        axisFormatMode: "auto",
+        axisVisibility: "show"
+      },
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const AREA_100P_VISUALIZATION = {
+  ...AREA_VISUALIZATION,
+  id: WizardVisualizationId.Area100p,
+  highchartsId: "area",
+  name: "label_visualization-area-100p",
+  availableLabelModes: ["absolute", "percent"],
+  iconProps: { id: "visArea100p", width: "24" }
+};
+const COLUMN_VISUALIZATION = {
+  id: WizardVisualizationId.Column,
+  type: "column",
+  name: "label_visualization-column",
+  iconProps: { id: "visColumn", width: "24" },
+  allowFilters: true,
+  allowColors: true,
+  allowSort: true,
+  allowSegments: true,
+  allowLabels: true,
+  checkAllowedSort: (item, visualization, colors, segments) => {
+    if (item.type === "MEASURE") {
+      return true;
+    }
+    const selectedItems = visualization.placeholders.reduce((a, b2) => a.concat(b2.items), []).concat(colors).concat(segments || []).filter((selectedItem) => selectedItem.type === "DIMENSION");
+    return selectedItems.some((selectedItem) => selectedItem.guid === item.guid);
+  },
+  checkAllowedDesignItems: lineCommonCheckColor,
+  checkAllowedLabels: linearCheckLabels,
+  availableLabelModes: ["absolute"],
+  onDesignItemsChange: onLineChartDesignItemsChange,
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.ALL,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES_AND_HIERARCHY,
+      id: "x",
+      type: "x",
+      title: "section_x",
+      iconProps: { data: ArrowRight },
+      items: [],
+      required: false,
+      capacity: 2,
+      settings: {
+        title: "off",
+        titleValue: "",
+        type: "linear",
+        grid: "on",
+        gridStep: "auto",
+        gridStepValue: 50,
+        hideLabels: "no",
+        labelsView: "auto",
+        holidays: "off",
+        axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+        axisLabelFormating: {},
+        axisFormatMode: "auto",
+        axisModeMap: {},
+        axisVisibility: "show"
+      },
+      transform: prepareFieldToDimensionTransformation
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "y",
+      type: "y",
+      title: "section_y",
+      iconProps: { data: ArrowUp },
+      items: [],
+      onChange: onMeasureAxisChange,
+      settings: {
+        scale: "auto",
+        scaleValue: AxisAutoScaleModes.Auto,
+        title: "off",
+        titleValue: "",
+        type: "linear",
+        grid: "on",
+        gridStep: "auto",
+        gridStepValue: 50,
+        hideLabels: "no",
+        labelsView: "auto",
+        nulls: AxisNullsMode.Ignore,
+        axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+        axisLabelFormating: {},
+        axisFormatMode: "auto",
+        axisVisibility: "show"
+      },
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const COLUMN_100P_VISUALIZATION = {
+  ...COLUMN_VISUALIZATION,
+  id: WizardVisualizationId.Column100p,
+  highchartsId: "column",
+  name: "label_visualization-column-100p",
+  availableLabelModes: ["absolute", "percent"],
+  iconProps: { id: "visColumn100p", width: "24" }
+};
+const BAR_VISUALIZATION = {
+  id: WizardVisualizationId.Bar,
+  type: "column",
+  name: "label_visualization-bar",
+  iconProps: { id: "visBar", width: "24" },
+  allowFilters: true,
+  allowColors: true,
+  allowSort: true,
+  allowLabels: true,
+  checkAllowedSort: (item, visualization, colors) => {
+    if (item.type === "MEASURE") {
+      return true;
+    }
+    const selectedItems = visualization.placeholders.reduce((a, b2) => a.concat(b2.items), []).concat(colors).filter((selectedItem) => selectedItem.type === "DIMENSION");
+    return selectedItems.some((selectedItem) => selectedItem.guid === item.guid);
+  },
+  checkAllowedDesignItems: lineCommonCheckColor,
+  checkAllowedLabels: linearCheckLabels,
+  availableLabelModes: ["absolute"],
+  onDesignItemsChange: onLineChartDesignItemsChange,
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.ALL,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES_AND_HIERARCHY,
+      id: "y",
+      type: "y",
+      title: "section_y",
+      iconProps: { data: ArrowDown },
+      items: [],
+      required: false,
+      capacity: 2,
+      settings: {
+        title: "off",
+        titleValue: "",
+        type: "linear",
+        grid: "on",
+        gridStep: "auto",
+        gridStepValue: 50,
+        hideLabels: "no",
+        labelsView: "auto",
+        axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+        axisLabelFormating: {},
+        axisFormatMode: "auto",
+        axisModeMap: {},
+        axisVisibility: "show"
+      },
+      transform: prepareFieldToDimensionTransformation
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "x",
+      type: "x",
+      title: "section_x",
+      iconProps: { data: ArrowRight },
+      items: [],
+      onChange: onMeasureAxisChange,
+      settings: {
+        scale: "auto",
+        scaleValue: AxisAutoScaleModes.Auto,
+        title: "off",
+        titleValue: "",
+        type: "linear",
+        grid: "on",
+        gridStep: "auto",
+        gridStepValue: 50,
+        hideLabels: "no",
+        labelsView: "auto",
+        nulls: AxisNullsMode.Ignore,
+        holidays: "off",
+        axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+        axisLabelFormating: {},
+        axisFormatMode: "auto",
+        axisVisibility: "show"
+      },
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const BAR_100P_VISUALIZATION = {
+  ...BAR_VISUALIZATION,
+  id: WizardVisualizationId.Bar100p,
+  highchartsId: "bar",
+  name: "label_visualization-bar-100p",
+  availableLabelModes: ["absolute", "percent"],
+  iconProps: { id: "visBar100p", width: "24" }
+};
+const METRIC_VISUALIZATION = {
+  id: "metric",
+  type: "metric",
+  name: "label_visualization-metric",
+  iconProps: { id: "visMetric", width: "24" },
+  allowFilters: true,
+  allowLabels: false,
+  allowSort: false,
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES_AND_MARKUP,
+      id: "measures",
+      type: "measures",
+      title: "section_measure",
+      iconProps: { data: SquareHashtag },
+      items: [],
+      required: true,
+      capacity: 1,
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const COMBINED_CHART_VISUALIZATION = {
+  id: "combined-chart",
+  highchartsId: "column",
+  type: "geo",
+  name: "label_visualization-combined-chart",
+  iconProps: { id: "visCombined", width: "24" },
+  layers: [createVisualizationLayer("line")],
+  selectedLayerId: "",
+  placeholders: []
+};
+const SCATTER_VISUALIZATION = {
+  id: WizardVisualizationId.Scatter,
+  type: "line",
+  name: "label_visualization-scatter",
+  iconProps: { id: "visScatter", width: "24" },
+  allowFilters: true,
+  allowColors: true,
+  allowShapes: true,
+  shapesCapacity: 1,
+  allowSort: true,
+  checkAllowedSort: (item, visualization) => {
+    if (item.type === "MEASURE") {
+      return false;
+    }
+    const selectedItems = visualization.placeholders.slice(0, 2).reduce((a, b2) => a.concat(b2.items), []).filter((selectedItem) => selectedItem.type === "DIMENSION");
+    return selectedItems.some((selectedItem) => selectedItem.guid === item.guid);
+  },
+  checkAllowedDesignItems: () => {
+    return true;
+  },
+  checkAllowedShapes: ({ item }) => item.type === "DIMENSION",
+  placeholders: [
+    {
+      allowedTypes: ITEM_TYPES.ALL,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES_AND_HIERARCHY,
+      id: "x",
+      type: "x",
+      title: "section_x",
+      iconProps: { data: ArrowRight },
+      items: [],
+      required: true,
+      capacity: 1,
+      settings: {
+        scale: "auto",
+        scaleValue: AxisAutoScaleModes.Auto,
+        title: "off",
+        titleValue: "",
+        type: "linear",
+        grid: "on",
+        gridStep: "auto",
+        gridStepValue: 50,
+        hideLabels: "no",
+        labelsView: "auto",
+        holidays: "off",
+        axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+        axisLabelFormating: {},
+        axisFormatMode: "auto",
+        axisModeMap: {},
+        axisVisibility: "show"
+      }
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "y",
+      type: "y",
+      title: "section_y",
+      iconProps: { data: ArrowUp },
+      items: [],
+      required: true,
+      capacity: 1,
+      settings: {
+        scale: "auto",
+        scaleValue: AxisAutoScaleModes.Auto,
+        title: "off",
+        titleValue: "",
+        type: "linear",
+        grid: "on",
+        gridStep: "auto",
+        gridStepValue: 50,
+        hideLabels: "no",
+        labelsView: "auto",
+        axisLabelDateFormat: DEFAULT_DATE_FORMAT,
+        axisLabelFormating: {},
+        axisFormatMode: "auto",
+        axisVisibility: "show"
+      },
+      onChange: onMeasureAxisChange
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES_AND_MARKUP,
+      id: "points",
+      type: "points",
+      title: "section_points",
+      iconProps: { data: Circles5Random },
+      items: [],
+      capacity: 1
+    },
+    {
+      allowedTypes: ITEM_TYPES.DIMENSIONS_AND_MEASURES,
+      allowedFinalTypes: ITEM_TYPES.MEASURES,
+      allowedDataTypes: PRIMITIVE_DATA_TYPES,
+      id: "size",
+      type: "measures",
+      title: "section_points_size",
+      iconProps: { data: ChevronsExpandUpRight },
+      items: [],
+      capacity: 1,
+      transform: prepareFieldToMeasureTransformation
+    }
+  ]
+};
+const SETTINGS = {
+  AXIS_FORMAT_MODE: {
+    AUTO: AxisLabelFormatMode.Auto,
+    BY_FIELD: AxisLabelFormatMode.ByField,
+    MANUAL: AxisLabelFormatMode.Manual
+  },
+  SCALE: {
+    AUTO: "auto",
+    MANUAL: "manual"
+  },
+  TITLE: {
+    AUTO: "auto",
+    MANUAL: "manual",
+    OFF: "off"
+  },
+  TYPE: {
+    LINEAR: "linear",
+    LOGARITHMIC: "logarithmic"
+  },
+  AXIS_VISIBILITY: {
+    SHOW: "show",
+    HIDE: "hide"
+  },
+  GRID: {
+    ON: "on",
+    OFF: "off"
+  },
+  GRID_STEP: {
+    AUTO: "auto",
+    MANUAL: "manual"
+  },
+  HIDE_LABELS: {
+    YES: "yes",
+    NO: "no"
+  },
+  LABELS_VIEW: {
+    AUTO: "auto",
+    HORIZONTAL: "horizontal",
+    VERTICAL: "vertical",
+    ANGLE: "angle"
+  },
+  NULLS: {
+    IGNORE: AxisNullsMode.Ignore,
+    CONNECT: AxisNullsMode.Connect,
+    AS_ZERO: AxisNullsMode.AsZero,
+    USE_PREVIOUS: AxisNullsMode.UsePrevious
+  },
+  HOLIDAYS: {
+    ON: "on",
+    OFF: "off"
+  },
+  POLYLINE_POINTS: {
+    ON: "on",
+    OFF: "off"
+  },
+  AXIS_MODE: {
+    DISCRETE: AxisMode.Discrete,
+    CONTINUOUS: AxisMode.Continuous
+  }
+};
+const CHART_SETTINGS = {
+  TITLE_MODE: {
+    SHOW: "show",
+    HIDE: "hide"
+  },
+  LEGEND: {
+    SHOW: LegendDisplayMode.Show,
+    HIDE: LegendDisplayMode.Hide
+  },
+  TOOLTIP: {
+    SHOW: "show",
+    HIDE: "hide"
+  },
+  TOOLTIP_SUM: {
+    ON: "on",
+    OFF: "off"
+  },
+  NAVIGATOR: {
+    SHOW: "show",
+    HIDE: "hide"
+  },
+  PAGINATION: {
+    ON: "on",
+    OFF: "off"
+  },
+  GROUPPING: {
+    ON: "on",
+    OFF: "off"
+  },
+  TOTALS: {
+    ON: "on",
+    OFF: "off"
+  },
+  PIVOT_FALLBACK: {
+    ON: "on",
+    OFF: "off"
+  },
+  OVERLAP: {
+    ON: "on",
+    OFF: "off"
+  },
+  LABELS_POSITION: {
+    INSIDE: LabelsPositions.Inside,
+    OUTSIDE: LabelsPositions.Outside
+  },
+  QL_AUTO_EXECUTION_CHART: {
+    ON: "on",
+    OFF: "off"
+  },
+  PIVOT_INLINE_SORT: {
+    ON: "on",
+    OFF: "off"
+  },
+  STACKING: {
+    ON: "on",
+    OFF: "off"
+  }
+};
+const VISUALIZATION_IDS = {
+  LINE: LINE_VISUALIZATION.id,
+  AREA: AREA_VISUALIZATION.id,
+  AREA_100P: AREA_100P_VISUALIZATION.id,
+  COLUMN: COLUMN_VISUALIZATION.id,
+  COLUMN_100P: COLUMN_100P_VISUALIZATION.id,
+  BAR: BAR_VISUALIZATION.id,
+  BAR_100P: BAR_100P_VISUALIZATION.id,
+  SCATTER: SCATTER_VISUALIZATION.id,
+  PIE: PIE_VISUALIZATION.id,
+  METRIC: METRIC_VISUALIZATION.id,
+  TREEMAP: TREEMAP_VISUALIZATION.id,
+  FLAT_TABLE: FLAT_TABLE_VISUALIZATION.id,
+  PIVOT_TABLE: PIVOT_TABLE_VISUALIZATION.id,
+  GEOPOINT: GEOPOINT_VISUALIZATION.id,
+  GEOPOINT_WITH_CLUSTER: GEOPOINT_WITH_CLUSTER_VISUALIZATION.id,
+  GEOPOLYGON: GEOPOLYGON_VISUALIZATION.id,
+  HEATMAP: HEATMAP_VISUALIZATION.id,
+  GEOLAYER: GEOLAYER_VISUALIZATION.id,
+  POLYLINE: POLYLINE_VISUALIZATION.id,
+  DONUT: DONUT_VISUALIZATION.id,
+  COMBINED_CHART: COMBINED_CHART_VISUALIZATION.id
+};
+const VISUALIZATIONS_BY_ID = {
+  [LINE_VISUALIZATION.id]: LINE_VISUALIZATION,
+  [AREA_VISUALIZATION.id]: AREA_VISUALIZATION,
+  [AREA_100P_VISUALIZATION.id]: AREA_100P_VISUALIZATION,
+  [COLUMN_VISUALIZATION.id]: COLUMN_VISUALIZATION,
+  [COLUMN_100P_VISUALIZATION.id]: COLUMN_100P_VISUALIZATION,
+  [BAR_VISUALIZATION.id]: BAR_VISUALIZATION,
+  [BAR_100P_VISUALIZATION.id]: BAR_100P_VISUALIZATION,
+  [SCATTER_VISUALIZATION.id]: SCATTER_VISUALIZATION,
+  [PIE_VISUALIZATION.id]: PIE_VISUALIZATION,
+  [METRIC_VISUALIZATION.id]: METRIC_VISUALIZATION,
+  [TREEMAP_VISUALIZATION.id]: TREEMAP_VISUALIZATION,
+  [FLAT_TABLE_VISUALIZATION.id]: FLAT_TABLE_VISUALIZATION,
+  [PIVOT_TABLE_VISUALIZATION.id]: PIVOT_TABLE_VISUALIZATION,
+  [GEOPOINT_VISUALIZATION.id]: GEOPOINT_VISUALIZATION,
+  [GEOPOINT_WITH_CLUSTER_VISUALIZATION.id]: GEOPOINT_WITH_CLUSTER_VISUALIZATION,
+  [GEOPOLYGON_VISUALIZATION.id]: GEOPOLYGON_VISUALIZATION,
+  [HEATMAP_VISUALIZATION.id]: HEATMAP_VISUALIZATION,
+  [GEOLAYER_VISUALIZATION.id]: GEOLAYER_VISUALIZATION,
+  [POLYLINE_VISUALIZATION.id]: POLYLINE_VISUALIZATION,
+  [DONUT_VISUALIZATION.id]: DONUT_VISUALIZATION,
+  [COMBINED_CHART_VISUALIZATION.id]: COMBINED_CHART_VISUALIZATION
+};
+const AVAILABLE_AGGREGATIONS_BY_COMMON_CAST = {
+  hierarchy: ["hierarchy"],
+  string: ["count", "countunique"],
+  number: ["avg", "count", "countunique", "max", "min", "sum"],
+  date: ["avg", "count", "countunique", "max", "min"],
+  boolean: ["count", "countunique"],
+  geo: ["count", "countunique"],
+  array: ["count", "countunique"],
+  markup: ["count"],
+  tree: []
+};
+const AVAILABLE_DATE_FORMATS = ["YYYY", "MM.YYYY", "DD.MM.YYYY", "YYYY-MM", "YYYY-MM-DD"];
+const AVAILABLE_DATE_FORMATS_NON_TABLE = ["DD.MM.YYYY", "YYYY-MM-DD"];
+const AVAILABLE_DATETIME_FORMATS = [
+  "YYYY",
+  "MM.YYYY",
+  "DD.MM.YYYY",
+  "DD.MM.YYYY HH",
+  "DD.MM.YYYY HH:mm",
+  "DD.MM.YYYY HH:mm:ss",
+  "YYYY-MM",
+  "YYYY-MM-DD",
+  "YYYY-MM-DD HH",
+  "YYYY-MM-DD HH:mm",
+  "YYYY-MM-DD HH:mm:ss"
+];
+const AVAILABLE_DATETIME_FORMATS_NON_TABLE = ["DD.MM.YYYY HH:mm:ss", "YYYY-MM-DD HH:mm:ss"];
+const AVAILABLE_DATETIMETZ_FORMATS = [
+  "YYYY",
+  "MM.YYYY",
+  "DD.MM.YYYY",
+  "DD.MM.YYYY HH",
+  "DD.MM.YYYY HH Z",
+  "DD.MM.YYYY HH:mm",
+  "DD.MM.YYYY HH:mm Z",
+  "DD.MM.YYYY HH:mm:ss",
+  "DD.MM.YYYY HH:mm:ss Z",
+  "YYYY-MM",
+  "YYYY-MM-DD",
+  "YYYY-MM-DD HH",
+  "YYYY-MM-DD HH Z",
+  "YYYY-MM-DD HH:mm",
+  "YYYY-MM-DD HH:mm Z",
+  "YYYY-MM-DD HH:mm:ss",
+  "YYYY-MM-DD HH:mm:ss Z"
+];
+const AVAILABLE_DATETIMETZ_FORMATS_NON_TABLE = ["DD.MM.YYYY HH:mm:ss Z", "YYYY-MM-DD HH:mm:ss Z"];
+const AVAILABLE_DATE_GROUPING_MODES = [
+  ["trunc", ["year", "quarter", "month", "week", "day"]],
+  ["part", ["year", "quarter", "month", "week", "day", "dayofweek"]]
+];
+const AVAILABLE_DATETIME_GROUPING_MODES = [
+  ["trunc", ["year", "quarter", "month", "week", "day", "hour", "minute", "second"]],
+  ["part", ["year", "quarter", "month", "week", "day", "dayofweek", "hour", "minute", "second"]]
+];
+var PaletteTypes = /* @__PURE__ */ ((PaletteTypes2) => {
+  PaletteTypes2["Lines"] = "lines";
+  PaletteTypes2["Colors"] = "colors";
+  PaletteTypes2["Points"] = "points";
+  return PaletteTypes2;
+})(PaletteTypes || {});
+const FILTER_SECTIONS = [PlaceholderId.Filters, PlaceholderId.DashboardFilters];
+const WIZARD_EDIT_HISTORY_UNIT_ID = "wizard";
+function getUniqueId(prefix = "id") {
+  return `${prefix}-${Date.now()}`;
+}
+function generateNextTitle(existedTitles, title) {
+  return existedTitles.reduce((nextTitle, currentTitle) => {
+    if (nextTitle === currentTitle) {
+      const match = nextTitle.match(/\((\d+)\)$/);
+      if (match) {
+        const i = Number(match[1]);
+        nextTitle = nextTitle.replace(/\((\d+)\)$/, `(${i + 1})`);
+      } else {
+        nextTitle = `${nextTitle} (1)`;
+      }
+    }
+    return nextTitle;
+  }, title);
+}
+var CommonDataType = /* @__PURE__ */ ((CommonDataType2) => {
+  CommonDataType2["Number"] = "number";
+  CommonDataType2["Date"] = "date";
+  CommonDataType2["Boolean"] = "boolean";
+  CommonDataType2["String"] = "string";
+  CommonDataType2["Geo"] = "geo";
+  CommonDataType2["Hierarchy"] = "hierarchy";
+  CommonDataType2["Array"] = "array";
+  CommonDataType2["Markup"] = "markup";
+  CommonDataType2["Tree"] = "tree";
+  return CommonDataType2;
+})(CommonDataType || {});
+function getCommonDataType$1(dataType) {
+  switch (dataType) {
+    case DATASET_FIELD_TYPES.INTEGER:
+    case DATASET_FIELD_TYPES.UINTEGER:
+    case DATASET_FIELD_TYPES.FLOAT:
+      return "number";
+    case DATASET_FIELD_TYPES.DATETIMETZ:
+    case DATASET_FIELD_TYPES.GENERICDATETIME:
+    case DATASET_FIELD_TYPES.DATE:
+      return "date";
+    case DATASET_FIELD_TYPES.GEOPOINT:
+    case DATASET_FIELD_TYPES.GEOPOLYGON:
+    case DATASET_FIELD_TYPES.HEATMAP:
+      return "geo";
+    case DATASET_FIELD_TYPES.BOOLEAN:
+      return "boolean";
+    case DATASET_FIELD_TYPES.HIERARCHY:
+      return "hierarchy";
+    case DATASET_FIELD_TYPES.ARRAY_FLOAT:
+    case DATASET_FIELD_TYPES.ARRAY_INT:
+    case DATASET_FIELD_TYPES.ARRAY_STR:
+      return "array";
+    case DATASET_FIELD_TYPES.TREE_FLOAT:
+    case DATASET_FIELD_TYPES.TREE_INT:
+    case DATASET_FIELD_TYPES.TREE_STR:
+      return "tree";
+    case DATASET_FIELD_TYPES.MARKUP:
+      return "markup";
+    case DATASET_FIELD_TYPES.STRING:
+    default:
+      return "string";
+  }
+}
+function getIconForDataType(dataType) {
+  const commonDataType = getCommonDataType$1(dataType);
+  switch (commonDataType) {
+    case "number":
+      return Hashtag;
+    case "date":
+      return Calendar;
+    case "geo": {
+      switch (dataType) {
+        case DATASET_FIELD_TYPES.GEOPOINT:
+          return GeoDots;
+        case DATASET_FIELD_TYPES.GEOPOLYGON:
+        default:
+          return GeoPolygons;
+      }
+    }
+    case "boolean":
+      return CopyCheckXmark;
+    case "hierarchy":
+      return Hierarchy;
+    case "array":
+      return SquareBracketsBarsVertical;
+    case "markup":
+      return SquareBracketsLetterA;
+    case "tree":
+      return BranchesDown;
+    case "string":
+    default:
+      return SquareLetterT;
+  }
+}
+function versionExtractor(key, value) {
+  if (!value) {
+    return void 0;
+  }
+  let target;
+  if (!Array.isArray(value) && typeof value === "object") {
+    target = getSortedData(value);
+  } else {
+    target = value;
+  }
+  if (key === "colors") {
+    return JSON.stringify(
+      target.map((item) => ({
+        guid: item.guid,
+        title: item.title,
+        fakeTitle: item.fakeTitle
+      }))
+    );
+  }
+  if (this["version"] === ChartsConfigVersion.V1 || typeof this["version"] === "undefined") {
+    if (key === "dataset") {
+      return {
+        id: target.id
+      };
+    }
+    if (key === "datasets") {
+      return JSON.stringify(target.map((dataset) => dataset.id));
+    }
+  }
+  if (key === "datasetsIds") {
+    return JSON.stringify(target.sort());
+  }
+  if (key === "datasetsPartialFields") {
+    return JSON.stringify(
+      target.reduce((acc, fields) => {
+        return [...acc, ...fields];
+      }, []).map((field) => field.guid).sort()
+    );
+  }
+  if (key === "dimensions") {
+    return void 0;
+  }
+  if (key === "measures") {
+    return void 0;
+  }
+  if (key === "colorsCapacity") {
+    return void 0;
+  }
+  if (key === "icon") {
+    return void 0;
+  }
+  if (key === "id") {
+    return void 0;
+  }
+  if (key === "filters") {
+    return JSON.stringify(
+      target.filter((item) => item && !item.unsaved).map((item) => {
+        const filterValue = item.filter.value || [];
+        const preparedFilterValue = Array.isArray(filterValue) ? filterValue : [filterValue];
+        const filterOperation = item.filter.operation.code;
+        return `${item.guid} ${filterOperation} ${preparedFilterValue.join()}`;
+      })
+    );
+  }
+  if (key === "hierarchies") {
+    return JSON.stringify(
+      target.map(
+        (item) => `${item.guid},${item.fields.map(
+          (item2) => JSON.stringify({ guid: item2.guid, columnSettings: item2.columnSettings })
+        ).join()}`
+      )
+    );
+  }
+  if (key === "items") {
+    return JSON.stringify(
+      target.map((item) => {
+        const formatting = item.formatting || {};
+        const columnSettings = item.columnSettings || {};
+        const barsSettings = item.barsSettings || {};
+        const backgroundSettings = item.backgroundSettings || {};
+        const subTotalsSettings = item.subTotalsSettings || {};
+        const hintSettings = item.hintSettings || {};
+        const { fakeTitle, format, hideLabelMode } = item;
+        return {
+          guid: item.guid,
+          fakeTitle,
+          format,
+          hideLabelMode,
+          formatting,
+          columnSettings,
+          barsSettings,
+          backgroundSettings,
+          subTotalsSettings,
+          hintSettings,
+          markupType: item.markupType
+        };
+      })
+    );
+  }
+  if (key === "colorsConfig") {
+    return JSON.stringify(target);
+  }
+  if (key === "geopointsConfig") {
+    return JSON.stringify(target);
+  }
+  if (key === "extraSettings") {
+    return JSON.stringify(target);
+  }
+  if (key === "labels") {
+    return JSON.stringify(
+      target.map((item) => {
+        const formatting = item.formatting || {};
+        return {
+          guid: item.guid,
+          formatting,
+          markupType: item.markupType
+        };
+      })
+    );
+  }
+  if (key === "links") {
+    return JSON.stringify(
+      target.map((item) => {
+        return {
+          id: item.id,
+          fields: Object.keys(item.fields).map((datasetId) => {
+            return {
+              datasetId,
+              fieldGuid: item.fields[datasetId].guid
+            };
+          })
+        };
+      })
+    );
+  }
+  if (key === "tooltips") {
+    return JSON.stringify(
+      target.map((item) => {
+        const { fakeTitle, format, formatting = {}, markupType } = item;
+        return { guid: item.guid, fakeTitle, format, formatting, markupType };
+      })
+    );
+  }
+  if (key === "shapes") {
+    return JSON.stringify(target.map((item) => item.guid));
+  }
+  if (key === "shapesConfig") {
+    return JSON.stringify(target);
+  }
+  if (key === "sort") {
+    return JSON.stringify(target.map((item) => `${item.guid} ${item.direction}`));
+  }
+  if (key === "segments") {
+    return JSON.stringify(target.map((item) => item.guid));
+  }
+  return target;
+}
+function getDefaultChartName({
+  dataset,
+  visualization
+}) {
+  if (dataset && dataset.realName && visualization && visualization.name) {
+    return `${dataset.realName} — ${i18n$5("wizard", visualization.name)}`;
+  } else {
+    return "";
+  }
+}
+function getDialogItem(items, placeholders) {
+  if (items[0] && !isPseudoField(items[0])) {
+    return items[0];
+  }
+  let placeholdersItems = [];
+  if (placeholders[0].id === PlaceholderId.Heatmap) {
+    placeholdersItems = [...placeholders[0].items];
+  }
+  if (placeholders[1]) {
+    placeholdersItems = [...placeholders[1].items];
+  }
+  if (placeholders[2]) {
+    placeholdersItems = placeholdersItems.concat(placeholders[2].items);
+  }
+  return placeholdersItems.length ? placeholdersItems : void 0;
+}
+function getSelectedLayerId(visualization) {
+  return visualization.selectedLayerId || visualization.layers[0].layerSettings.id;
+}
+function getSelectedLayer(visualization) {
+  const layerId = getSelectedLayerId(visualization);
+  return visualization.layers.find(({ layerSettings: { id } }) => id === layerId);
+}
+function checkAllowedAreaSort(item, visualization, colors, segments) {
+  if (item.type === "MEASURE") {
+    return true;
+  }
+  const selectedItems = visualization.placeholders.reduce((a, b2) => a.concat(b2.items), []).concat(colors).concat(segments || []);
+  return selectedItems.some((selectedItem) => selectedItem.guid === item.guid);
+}
+function getVisualization(globalVisualization) {
+  if (isVisualizationWithLayers(globalVisualization)) {
+    return getSelectedLayer(globalVisualization);
+  } else {
+    return globalVisualization;
+  }
+}
+function actualizeUpdates({
+  updates,
+  visualization,
+  sectionDatasetFields,
+  onUpdateItemsGuids = [],
+  visualizationFields
+}) {
+  const currentVisualization = getVisualization(visualization);
+  if (!currentVisualization) {
+    return updates;
+  }
+  const getFieldKey = (field) => `${field.datasetId}__${field.guid}`;
+  const sectionDatasetFieldsGuids = sectionDatasetFields.reduce(
+    (acc, field) => {
+      acc[getFieldKey(field)] = field;
+      return acc;
+    },
+    {}
+  );
+  const placeholders = currentVisualization?.placeholders || [];
+  const placeholdersItems = placeholders.reduce((acc, placeholder) => {
+    const items = placeholder.items || [];
+    return [...acc, ...items];
+  }, []);
+  const sectionVisualizationFields = [
+    ...placeholdersItems.map((field) => pick$1(field, "guid", "datasetId")),
+    ...visualizationFields.map((field) => pick$1(field, "guid", "datasetId")),
+    ...onUpdateItemsGuids
+  ].reduce((acc, field) => {
+    acc[getFieldKey(field)] = field;
+    return acc;
+  }, {});
+  return updates.filter((update) => {
+    const field = update.field;
+    const key = getFieldKey(field);
+    return sectionDatasetFieldsGuids[key] && isFieldVisible(field) || sectionVisualizationFields[key];
+  });
+}
+function sorterByLowerCase(a, b2) {
+  return a.title.toLowerCase() > b2.title.toLowerCase() ? 1 : -1;
+}
+function fieldMerge({
+  source,
+  target
+}) {
+  CLIENT_SIDE_FIELD_PROPS.forEach((prop) => {
+    if (source[prop]) {
+      target[prop] = source[prop];
+    }
+  });
+}
+function transformSchema({ schema, widgetDataset, dataset }) {
+  const measures = [];
+  const dimensions = [];
+  const { id: datasetId } = dataset;
+  schema.forEach((item, index) => {
+    let type;
+    let container;
+    if (item.type === "MEASURE") {
+      type = "measure";
+      container = measures;
+    } else if (item.type === "DIMENSION") {
+      type = "dimension";
+      container = dimensions;
+    } else {
+      return;
+    }
+    const itemCopy = { ...item };
+    itemCopy.datasetId = datasetId;
+    item.datasetId = datasetId;
+    itemCopy.id = `${type}-${index}`;
+    itemCopy.data_type = item.data_type || item.cast;
+    if (widgetDataset) {
+      const widgetResultSchemaItem = getResultSchemaFromDataset(widgetDataset).find(
+        (widgetItem) => {
+          return widgetItem.guid === item.guid;
+        }
+      );
+      if (widgetResultSchemaItem) {
+        fieldMerge({ source: widgetResultSchemaItem, target: itemCopy });
+      }
+    }
+    itemCopy.datasetName = dataset.realName;
+    container.push(itemCopy);
+  });
+  measures.sort(sorterByLowerCase);
+  dimensions.sort(sorterByLowerCase);
+  return { dimensions, measures };
+}
+function extractFieldsFromDatasets(datasets) {
+  return datasets.reduce((fields, dataset) => {
+    const schema = getResultSchemaFromDataset(dataset);
+    const { measures, dimensions } = transformSchema({ schema, dataset });
+    return [...fields, ...measures, ...dimensions];
+  }, []);
+}
+function getKeysWithoutConfigs(key) {
+  return !["colorsConfig", "geopointsConfig", "shapesConfig", "tooltipConfig"].includes(key);
+}
+function getAllCommonPlaceholdersFields(commonPlaceholders) {
+  return commonPlaceholders.reduce((acc, curr) => {
+    const keys = Object.keys(curr);
+    const keysWithoutConfigs = keys.filter(getKeysWithoutConfigs);
+    const fields = getCommonPlaceholderFields(curr, keysWithoutConfigs);
+    return [...acc, ...fields];
+  }, []);
+}
+function getCommonPlaceholderFields(commonPlaceholders, keysWithoutConfigs) {
+  return keysWithoutConfigs.reduce((acc, key) => {
+    const placeholderFields = commonPlaceholders[key] || [];
+    return [...acc, ...placeholderFields];
+  }, []);
+}
+function shouldComponentUpdateWithDeepComparison({
+  nextProps,
+  currentProps,
+  deepComparePropKey
+}) {
+  return Object.keys(nextProps).some((currentKey) => {
+    if (currentKey === deepComparePropKey && currentProps[currentKey] !== nextProps[currentKey]) {
+      return !isEqual(currentProps[currentKey], nextProps[currentKey]);
+    }
+    return currentProps[currentKey] !== nextProps[currentKey];
+  });
+}
+const getGeolayerGroups = () => {
+  return ["geopoint", "geopoint-with-cluster", "polyline", "geopolygon", "heatmap"].filter(
+    Boolean
+  );
+};
+const prepareFieldForUpdate = ({
+  field,
+  groupingChanged
+}) => {
+  if (!field.autoaggregated) {
+    if (field.aggregation === "none") {
+      field.type = DatasetFieldType.Dimension;
+    } else {
+      field.type = DatasetFieldType.Measure;
+    }
+  }
+  if (groupingChanged && field.grouping && field.grouping === "none") {
+    field.formula = field.originalFormula || "";
+    field.cast = field.originalDateCast || field.cast;
+    field.data_type = field.originalDateCast || field.data_type;
+    field.source = field.originalSource || field.source;
+    delete field.originalDateCast;
+    delete field.originalSource;
+  } else if (groupingChanged && field.grouping) {
+    const [operation, mode] = field.grouping.split("-");
+    let functionName;
+    if (operation === "trunc") {
+      functionName = "datetrunc";
+    } else {
+      functionName = "datepart";
+      field.data_type = DATASET_FIELD_TYPES.INTEGER;
+      field.cast = DATASET_FIELD_TYPES.INTEGER;
+    }
+    if (field.source) {
+      field.formula = `${functionName}([${field.source}], "${mode}")`;
+      field.originalDateCast = field.cast;
+      field.originalSource = field.source;
+      field.source = "";
+    } else {
+      const argument = field.originalSource ? `[${field.originalSource}]` : field.originalFormula;
+      field.formula = `${functionName}(${argument}, "${mode}")`;
+    }
+    delete field.cast;
+    delete field.data_type;
+  }
+  if (field.formula) {
+    field.calc_mode = "formula";
+  } else {
+    field.calc_mode = "direct";
+  }
+  return field;
+};
+const prepareFieldForCreate = ({
+  field,
+  dataset
+}) => {
+  const { calc_mode: calcMode } = field;
+  const fieldNext = {
+    ...field,
+    datasetId: dataset.id
+  };
+  if (calcMode === "formula") {
+    delete fieldNext.cast;
+    delete fieldNext.data_type;
+  }
+  return fieldNext;
+};
+const getCommonDataType = (field) => {
+  const { data_type: dataType } = field;
+  switch (dataType) {
+    case "integer":
+    case "uinteger":
+    case "float": {
+      return CommonDataType.Number;
+    }
+    case "date":
+    case "genericdatetime":
+    case "datetimetz": {
+      return CommonDataType.Date;
+    }
+    case "boolean": {
+      return CommonDataType.Boolean;
+    }
+    case "array_str":
+    case "array_int":
+    case "array_float": {
+      return CommonDataType.Array;
+    }
+    case "string":
+    default: {
+      return CommonDataType.String;
+    }
+  }
+};
+const getAvailableOperations = (field, filterOperations) => {
+  const { type } = field;
+  const commonDataType = getCommonDataType(field);
+  let availableOperations;
+  switch (commonDataType) {
+    case CommonDataType.Number: {
+      availableOperations = type === DatasetFieldType.Measure ? MEASURE_NUMBER_OPERATIONS : DIMENSION_NUMBER_OPERATIONS;
+      break;
+    }
+    case CommonDataType.Date: {
+      availableOperations = DATE_OPERATIONS;
+      break;
+    }
+    case CommonDataType.Boolean: {
+      availableOperations = BOOLEAN_OPERATIONS;
+      break;
+    }
+    case CommonDataType.Array: {
+      availableOperations = ARRAY_OPERATIONS;
+      break;
+    }
+    case CommonDataType.String:
+    default: {
+      availableOperations = STRING_OPERATIONS;
+    }
+  }
+  return availableOperations.filter(({ value }) => filterOperations.includes(value));
+};
+const iconArrow = "data:image/svg+xml,%3csvg%20width='24'%20height='24'%20viewBox='0%200%2024%2024'%20stroke='currentColor'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M19%2011.8421L5%2011.8421M5%2011.8421L10.1579%2017M5%2011.8421L10.1579%206.68421'%20stroke-width='2'%20stroke-linecap='round'/%3e%3c/svg%3e";
+const DIALOG_FILTER = /* @__PURE__ */ Symbol("DIALOG_FILTER");
+const b = block("dl-dialog-filter");
+const i18n = I18n.keyset("component.dl-dialog-filter.view");
+const collator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
+const VALUES_LOAD_LIMIT = 1e3;
+const DEBOUNCE_DELAY = 250;
+const OPERATIONS_WITHOUT_VALUE = [
+  Operations.ISNULL,
+  Operations.ISNOTNULL,
+  Operations.NO_SELECTED_VALUES
+];
+const SELECTABLE_OPERATIONS = [Operations.IN, Operations.NIN];
+class DialogFilter extends React__default.Component {
+  constructor(props) {
+    super(props);
+    this.isUnmounted = false;
+    this.isApplyButtonDisabled = () => {
+      if (!this.state.valid) {
+        return true;
+      }
+      const { filter } = this.props;
+      const { values, dimensions, useSuggest } = this.state;
+      const operation = this.state.operation;
+      const isSameOperation = Boolean(filter && operation.value === filter.operation);
+      const isValuesEmpty = !values.length;
+      switch (operation.value) {
+        case Operations.IN:
+        case Operations.NIN: {
+          const isOnlyOneValueAndEmpty = values.length === 1 && values[0] === "";
+          const hasMissingValue = values.length === 1 && dimensions.length > 0 && !dimensions.includes(values[0] || "") && !useSuggest;
+          if (filter) {
+            const isValuesEqual = _.isEqual(values, filter.values);
+            return isValuesEmpty || isValuesEqual && isSameOperation || hasMissingValue;
+          }
+          return isValuesEmpty || hasMissingValue || isOnlyOneValueAndEmpty;
+        }
+        case Operations.ISNULL:
+        case Operations.ISNOTNULL: {
+          if (filter) {
+            return isSameOperation;
+          }
+          return false;
+        }
+        default: {
+          if (filter) {
+            const isValuesEqual = operation.selectable ? _.isEqual(values, filter.values) : values[0] === filter.values[0];
+            return isValuesEmpty || isValuesEqual && isSameOperation;
+          }
+          return isValuesEmpty;
+        }
+      }
+    };
+    this.getDistincts = (datasetId, field, filters = []) => {
+      const { updates = [], parameters = [], dashboardParameters = [], workbookId } = this.props;
+      const fields = getFieldsApiV2RequestSection([field], "distinct");
+      const parameter_values = getParametersApiV2RequestSection({
+        parameters,
+        dashboardParameters
+      });
+      getSdk().cancelRequest("getDistincts");
+      return getSdk().sdk.bi.getDistinctsApiV2(
+        {
+          datasetId,
+          workbookId,
+          fields,
+          limit: VALUES_LOAD_LIMIT,
+          updates,
+          filters,
+          parameter_values
+        },
+        { concurrentId: "getDistincts", timeout: TIMEOUT_90_SEC }
+      );
+    };
+    this.fetchDistincts = async (field) => {
+      const { datasetId, options } = this.props;
+      try {
+        this.setState({ fetching: true });
+        const whereOperation = getWhereOperation(field, options);
+        const data = await this.getDistincts(datasetId, field);
+        const dimensions = data.result.data.Data.map((row) => row[0]).sort(
+          collator.compare
+        );
+        const useSuggest = Boolean(dimensions.length === VALUES_LOAD_LIMIT && whereOperation);
+        if (this.isUnmounted) {
+          return;
+        }
+        this.setState({
+          dimensions,
+          whereOperation,
+          useSuggest,
+          prepared: true,
+          fetching: false
+        });
+      } catch (error) {
+        if (this.isUnmounted || getSdk().sdk.isCancel(error)) {
+          return;
+        }
+        logger.logError("DialogFilter: fetchDistincts failed", error);
+        this.setState({
+          /* prepared and useManualInput flags are fallbacks for sources,
+          for which the query of distinkts does not work, as well as for fallen queries*/
+          prepared: true,
+          useManualInput: true,
+          fetching: false
+        });
+      }
+    };
+    this.prepareFilter = (field, operation) => {
+      if (operation.selectable) {
+        this.fetchDistincts(field);
+      }
+    };
+    this.onArrowBackClick = () => {
+      this.setState({
+        field: null,
+        viewMode: ViewMode.Fields
+      });
+    };
+    this.onFiledItemClick = (field) => {
+      const { options } = this.props;
+      const filterOperations = getFilterOperations(field, options);
+      const availableOperations = getAvailableOperations(field, filterOperations);
+      const operation = availableOperations[0];
+      this.prepareFilter(field, operation);
+      this.setState({
+        field,
+        availableOperations,
+        operation,
+        values: [],
+        viewMode: ViewMode.Filters
+      });
+    };
+    this.onChangeValue = (values, meta) => {
+      const { operation } = this.state;
+      const { needSort = true, valid = true } = meta || {};
+      const isSelectable = SELECTABLE_OPERATIONS.includes(operation?.value);
+      let newValues = [...values];
+      if (needSort) {
+        newValues = newValues.sort(collator.compare);
+      }
+      const updatedState = {
+        valid,
+        values: newValues,
+        ...isSelectable && { selectableValues: newValues }
+      };
+      this.setState(updatedState);
+    };
+    this.onChangeOperation = ([value]) => {
+      const prevOperation = this.state.operation;
+      if (prevOperation?.value === Operations.NO_SELECTED_VALUES && value !== Operations.NO_SELECTED_VALUES) {
+        const filteredAvailableOperations = this.state.availableOperations.filter(
+          (op) => op.value !== Operations.NO_SELECTED_VALUES
+        );
+        this.setState({ availableOperations: filteredAvailableOperations });
+      }
+      const { availableOperations, prepared, fetching } = this.state;
+      const operation = availableOperations.find((op) => op.value === value);
+      if (!prepared && operation.selectable && !fetching) {
+        this.prepareFilter(this.field, operation);
+      }
+      this.setState({ operation });
+    };
+    this.onChangeSuggest = async (search) => {
+      if (!this.field || this.state.fetching) {
+        return;
+      }
+      try {
+        const { datasetId } = this.props;
+        const { whereOperation } = this.state;
+        let where;
+        this.setState({ suggestFetching: true });
+        if (search && whereOperation) {
+          where = [
+            {
+              values: [search],
+              operation: whereOperation,
+              ref: { type: "id", id: this.field.guid }
+            }
+          ];
+        }
+        const data = await this.getDistincts(datasetId, this.field, where);
+        const dimensions = data.result.data.Data.map((row) => row[0]).sort(
+          collator.compare
+        );
+        if (this.isUnmounted) {
+          return;
+        }
+        this.setState({
+          dimensions,
+          suggestFetching: false
+        });
+      } catch (error) {
+        if (this.isUnmounted || getSdk().sdk.isCancel(error)) {
+          return;
+        }
+        logger.logError("DialogFilter: onChangeSuggest failed", error);
+        this.setState({ suggestFetching: false });
+      }
+    };
+    this.onApply = () => {
+      const { filter } = this.props;
+      const { useManualInput } = this.state;
+      const { guid: fieldGuid } = this.field;
+      const { selectable, value: operationValue } = this.state.operation;
+      let values = [...this.state.values];
+      let filterId;
+      if (OPERATIONS_WITHOUT_VALUE.includes(operationValue)) {
+        values = [];
+      } else if (useManualInput && selectable) {
+        values = values.filter(Boolean);
+      } else if (!selectable) {
+        values = values.slice(0, 1);
+      }
+      if (filter) {
+        filterId = filter.filterId;
+      }
+      this.props.onApply({
+        values,
+        fieldGuid,
+        filterId,
+        operation: operationValue
+      });
+    };
+    this.onClose = () => {
+      this.props.onClose();
+    };
+    this.debouncedChangeSuggest = (search) => {
+      if (this.debounced) {
+        this.debounced.cancel();
+      }
+      this.debounced = _.debounce(this.onChangeSuggest, DEBOUNCE_DELAY);
+      this.debounced(search);
+    };
+    this.debouncedApply = _.debounce(this.onApply, 60);
+    this.state = {
+      viewMode: ViewMode.Fields,
+      availableOperations: [],
+      values: [],
+      selectableValues: [],
+      dimensions: [],
+      field: null,
+      operation: null,
+      whereOperation: null,
+      valid: true,
+      prepared: false,
+      useSuggest: false,
+      useManualInput: false,
+      fetching: false,
+      suggestFetching: false
+    };
+  }
+  componentDidMount() {
+    const { field, filter, options } = this.props;
+    if (!field) {
+      return;
+    }
+    const filterOperations = getFilterOperations(field, options);
+    let availableOperations = getAvailableOperations(field, filterOperations);
+    if ("unsaved" in field && field.unsaved && filter?.operation === Operations.NO_SELECTED_VALUES) {
+      availableOperations = [NO_SELECTED_VALUES_OPERATION, ...availableOperations];
+    }
+    const operation = filter ? availableOperations.find((op) => op.value === filter.operation) || availableOperations[0] : availableOperations[0];
+    const values = filter ? filter.values : [];
+    this.prepareFilter(field, operation);
+    this.setState({
+      availableOperations,
+      operation,
+      values,
+      selectableValues: values,
+      viewMode: ViewMode.Filters
+    });
+  }
+  componentDidUpdate(_prevProps, prevState) {
+    const { operation, selectableValues } = this.state;
+    const prevOperation = prevState.operation?.value;
+    const currentOperation = operation?.value;
+    if (!prevOperation || !currentOperation) {
+      return;
+    }
+    if (prevOperation !== currentOperation && !SELECTABLE_OPERATIONS.includes(prevOperation) && SELECTABLE_OPERATIONS.includes(currentOperation)) {
+      this.onChangeSuggest("");
+      this.setState({ values: selectableValues });
+    }
+  }
+  componentWillUnmount() {
+    this.isUnmounted = true;
+  }
+  render() {
+    const { visible } = this.props;
+    return /* @__PURE__ */ jsx(
+      Dialog,
+      {
+        open: visible,
+        onClose: this.onClose,
+        onEnterKeyDown: () => {
+          if (this.isApplyButtonDisabled()) {
+            return;
+          }
+          this.onApply();
+        },
+        children: /* @__PURE__ */ jsxs("div", { className: b(), children: [
+          this.renderHeader(),
+          this.renderBody(),
+          /* @__PURE__ */ jsx(Dialog.Divider, { className: b("divider") }),
+          this.renderFooter()
+        ] })
+      }
+    );
+  }
+  get field() {
+    return this.props.field || this.state.field;
+  }
+  renderHeader() {
+    const { viewMode } = this.state;
+    if (viewMode === ViewMode.Fields || !this.field) {
+      return /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n("label_header-title") });
+    }
+    const { title, type, data_type: dataType } = this.field;
+    return /* @__PURE__ */ jsx(
+      Dialog.Header,
+      {
+        caption: title,
+        insertBefore: /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+          !this.props.field && /* @__PURE__ */ jsx(
+            Button,
+            {
+              className: b("arrow-back-button"),
+              size: "s",
+              view: "flat",
+              onClick: this.onArrowBackClick,
+              children: /* @__PURE__ */ jsx(Icon, { data: iconArrow, size: 20 })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            DataTypeIcon,
+            {
+              fieldType: type,
+              dataType,
+              className: b("header-title-icon")
+            }
+          )
+        ] })
+      }
+    );
+  }
+  renderBody() {
+    const { fields = [] } = this.props;
+    const { viewMode, operation, useManualInput, fetching } = this.state;
+    const mods = {
+      "without-paddings": viewMode === ViewMode.Filters && operation?.selectable && !useManualInput,
+      "without-horizontal-paddings": viewMode === ViewMode.Fields,
+      mode: ViewMode.Fields
+    };
+    if (viewMode === ViewMode.Fields || !operation) {
+      return /* @__PURE__ */ jsx(Dialog.Body, { className: b("body", mods), children: /* @__PURE__ */ jsx(
+        DatasetFieldList,
+        {
+          fields,
+          itemHeight: LIST_ITEM_HEIGHT,
+          onFiledItemClick: this.onFiledItemClick
+        }
+      ) });
+    }
+    return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      this.renderOperationSection(),
+      /* @__PURE__ */ jsx(Dialog.Divider, {}),
+      /* @__PURE__ */ jsx("div", { className: b("body", mods), children: fetching && operation.selectable ? /* @__PURE__ */ jsx("div", { className: b("loader"), children: /* @__PURE__ */ jsx(Loader, { size: "m" }) }) : this.renderFilterSection() })
+    ] });
+  }
+  renderOperationSection() {
+    const { availableOperations, operation } = this.state;
+    const options = availableOperations.map(
+      (item) => ({
+        value: item.value,
+        content: item.title,
+        qa: item.value
+      })
+    );
+    const value = operation?.value ? [operation.value] : [];
+    return /* @__PURE__ */ jsxs("div", { className: b("operation"), children: [
+      /* @__PURE__ */ jsx("span", { className: b("operation-label"), children: i18n("label_operation") }),
+      /* @__PURE__ */ jsx("div", { className: b("operation-select"), children: /* @__PURE__ */ jsx(
+        Select,
+        {
+          value,
+          options,
+          onUpdate: this.onChangeOperation,
+          qa: "operation-select"
+        }
+      ) })
+    ] });
+  }
+  renderFilterSection() {
+    const { values, operation, dimensions, useSuggest, useManualInput, suggestFetching } = this.state;
+    const operationValue = operation?.value || "";
+    if (!operation || !this.field || OPERATIONS_WITHOUT_VALUE.includes(operationValue)) {
+      return null;
+    }
+    if (operation.selectable && !useManualInput) {
+      return /* @__PURE__ */ jsx(
+        SelectFilter,
+        {
+          values,
+          dimensions,
+          useSuggest,
+          suggestFetching,
+          changeValue: this.onChangeValue,
+          onChangeSuggest: this.debouncedChangeSuggest
+        }
+      );
+    }
+    const commonDataType = getCommonDataType(this.field);
+    switch (commonDataType) {
+      case CommonDataType.Boolean: {
+        return /* @__PURE__ */ jsx(BooleanFilter, { values, changeValue: this.onChangeValue });
+      }
+      case CommonDataType.Date: {
+        return /* @__PURE__ */ jsx(
+          DateFilter,
+          {
+            values,
+            field: this.field,
+            operation,
+            changeValue: this.onChangeValue
+          }
+        );
+      }
+      default: {
+        return /* @__PURE__ */ jsx(
+          InputFilter,
+          {
+            values,
+            selectable: operation.selectable,
+            changeValue: this.onChangeValue
+          }
+        );
+      }
+    }
+  }
+  renderFooter() {
+    const { dimensions, viewMode, useSuggest } = this.state;
+    const { hideApplyButton } = this.props;
+    if (viewMode === ViewMode.Fields) {
+      return null;
+    }
+    let textButtonApply;
+    let onClickButtonApply;
+    if (!hideApplyButton) {
+      textButtonApply = i18n("button_apply");
+      onClickButtonApply = this.debouncedApply;
+    }
+    return /* @__PURE__ */ jsx(
+      Dialog.Footer,
+      {
+        onClickButtonCancel: this.onClose,
+        onClickButtonApply,
+        textButtonApply,
+        textButtonCancel: i18n("button_cancel"),
+        propsButtonApply: {
+          disabled: this.isApplyButtonDisabled()
+        },
+        children: useSuggest && dimensions.length === VALUES_LOAD_LIMIT && /* @__PURE__ */ jsx("span", { className: b("load-limit-reached-warn"), children: i18n("label_load-limit-reached-warn") })
+      }
+    );
+  }
+}
+const DialogFilterComponent = withHiddenUnmount(DialogFilter);
+DialogManager.registerDialog(DIALOG_FILTER, DialogFilterComponent);
+export {
+  GEOLAYER_VISUALIZATION as $,
+  AREA_VISUALIZATION as A,
+  BOOLEAN_OPERATIONS as B,
+  COLUMN_VISUALIZATION as C,
+  DIALOG_FILTER as D,
+  DEFAULT_PAGE_ROWS_LIMIT as E,
+  FLAT_TABLE_VISUALIZATION as F,
+  validateThresholds as G,
+  DEFAULT_PALETTE_STATE as H,
+  ALLOWED_FOR_NULL_MODE_VISUALIZATIONS as I,
+  DEFAULT_TWO_POINT_GRADIENT as J,
+  DEFAULT_GRADIENT_MODE as K,
+  LINE_VISUALIZATION as L,
+  METRIC_VISUALIZATION as M,
+  NULLS_OPTIONS as N,
+  removeUrlParameters as O,
+  PIE_VISUALIZATION as P,
+  WIZARD_DATASET_ID_PARAMETER_KEY as Q,
+  getChangedPlaceholderSettings as R,
+  SCATTER_VISUALIZATION as S,
+  TREEMAP_VISUALIZATION as T,
+  getDefaultVisualization as U,
+  VISUALIZATIONS_BY_ID as V,
+  WIZARD_EDIT_HISTORY_UNIT_ID as W,
+  getFiltersFields as X,
+  getParametersFields as Y,
+  getChartFiltersWithDisabledProp as Z,
+  convertVisualizationToGeolayer as _,
+  DL_ADAPTIVE_TABS_BREAK_POINT_CONFIG as a,
+  updateVisualizationLayerType as a0,
+  getUpdatedLayers as a1,
+  DEFAULT_GRADIENT_STATE as a2,
+  getPlaceholdersWithMergedSettings as a3,
+  clearUnusedVisualizationItems as a4,
+  getSelectedLayerId as a5,
+  versionExtractor as a6,
+  MOD_KEY as a7,
+  HOTKEYS_SCOPES as a8,
+  UNDO_HOTKEY as a9,
+  PRIMITIVE_DATA_TYPES as aA,
+  prepareFieldToMeasureTransformation as aB,
+  getDefaultExtraSettings as aC,
+  getDefaultVisualisationExtraSettings as aD,
+  generateNextTitle as aE,
+  prepareFieldForCreate as aF,
+  DATASET_ERRORS as aG,
+  shouldComponentUpdateWithDeepComparison as aH,
+  REDO_HOTKEY as aa,
+  getExistedParameterKeys as ab,
+  FILTER_SECTIONS as ac,
+  getUniqueId as ad,
+  getCommonDataType$1 as ae,
+  AVAILABLE_DATE_GROUPING_MODES as af,
+  AVAILABLE_DATETIME_GROUPING_MODES as ag,
+  AVAILABLE_FIELD_TYPES as ah,
+  AVAILABLE_AGGREGATIONS_BY_COMMON_CAST as ai,
+  AVAILABLE_DATETIME_FORMATS as aj,
+  AVAILABLE_DATETIME_FORMATS_NON_TABLE as ak,
+  AVAILABLE_DATETIMETZ_FORMATS as al,
+  AVAILABLE_DATETIMETZ_FORMATS_NON_TABLE as am,
+  AVAILABLE_DATE_FORMATS_NON_TABLE as an,
+  HIDE_LABEL_MODES as ao,
+  prepareFieldForUpdate as ap,
+  parseFilterDate as aq,
+  parseParameterDefaultValue as ar,
+  CONFLICT_TOOLTIPS as as,
+  getGeolayerGroups as at,
+  createVisualizationLayer as au,
+  ITEM_TYPES as av,
+  getDialogItem as aw,
+  PRIMITIVE_DATA_TYPES_AND_HIERARCHY as ax,
+  appendUrlParameters as ay,
+  updateUrlParameter as az,
+  DEFAULT_DATE_FORMAT as b,
+  isFieldVisible as c,
+  getVisualization as d,
+  extractFieldsFromDatasets as e,
+  getSelectedLayer as f,
+  getAvailableOperations as g,
+  getAllCommonPlaceholdersFields as h,
+  iconCross as i,
+  actualizeUpdates as j,
+  getAvailableVisualizations as k,
+  fieldMerge as l,
+  VISUALIZATION_IDS as m,
+  AREA_100P_VISUALIZATION as n,
+  COLUMN_100P_VISUALIZATION as o,
+  BAR_VISUALIZATION as p,
+  BAR_100P_VISUALIZATION as q,
+  DONUT_VISUALIZATION as r,
+  getIconForDataType as s,
+  transformSchema as t,
+  CHART_SETTINGS as u,
+  PaletteTypes as v,
+  SETTINGS as w,
+  AREA_OR_AREA100P as x,
+  AVAILABLE_DATE_FORMATS as y,
+  getDefaultChartName as z
+};