@retailcrm/datalens-ui 0.0.0

package/components/DialogRelations.js

@@ -0,0 +1,3389 @@
+import { useDispatch, useSelector, batch } from "react-redux";
+import { jsxs, jsx } from "react/jsx-runtime";
+import React__default from "react";
+import { Xmark, Magnifier, TrashBin, ChevronDown, TriangleExclamationFill, Check, Plus } from "@gravity-ui/icons";
+import { TextInput, Button, Icon, DropdownMenu, Popover, Loader, Dialog, Select, Popup, Link, HelpMark, Alert } from "@gravity-ui/uikit";
+import block from "bem-cn-lite";
+import { D as DialogManager } from "./DialogManager.js";
+import { l as I18n, u as DashTabItemType, ah as DashTabItemControlSourceType, j as i18n$9, bs as DashCommonQa, c4 as DashRelationTypes, D as DL } from "./AccessRights.js";
+import intersection from "lodash/intersection";
+import isEmpty from "lodash/isEmpty";
+import isEqual from "lodash/isEqual";
+import { a as selectDebugMode } from "./AsideHeaderAdapter.js";
+import { S as SelectOptionWithIcon } from "./SelectComponents.js";
+import { D as DASH_WIDGET_TYPES, aB as DASH_FILTERING_CHARTS_WIDGET_TYPES, aC as DASH_ACCEPT_FILTERING_CHARTS_WIDGET_TYPES, aD as CONNECTION_KIND, aE as getAllTabItems, l as isGlobalWidgetVisibleByMainSetting, m as isGroupItemVisibleOnTab, ak as selectCurrentTabId, aF as selectCurrentTabAliases, e as selectDashWorkbookId, aG as selectCurrentTabRelationDataItems, aH as selectWidgetsCurrentTab, aI as updateCurrentTabData, aJ as selectDashkitRef } from "./ControlComponents.js";
+import { C as Collapse } from "./Collapse.js";
+import iconEditorChart from "@gravity-ui/icons/svgs/curly-brackets.svg";
+import LogoMarkdownIcon from "@gravity-ui/icons/svgs/logo-markdown.svg";
+import cloneDeep from "lodash/cloneDeep";
+import { V as VISUALIZATIONS_BY_ID } from "./DialogFilter.js";
+import { I as IconById } from "./IconById.js";
+import { g as getSdk, o as openDialog, c as closeDialog } from "./ActionPanel.js";
+import { I as Interpolate } from "./Interpolate.js";
+import { P as PlaceholderIllustration } from "./PlaceholderIllustration.js";
+import { i as iconInfo } from "./CollectionsStructure.js";
+const iconFlatTable = "data:image/svg+xml,%3csvg%20width='20'%20height='20'%20viewBox='0%200%2020%2020'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M2.083%204.167h3.333c.23%200%20.417.187.417.417v.833c0%20.23-.186.417-.417.417H2.083a.417.417%200%200%201-.417-.417v-.833c0-.23.187-.417.417-.417Zm5.833%200h3.334c.23%200%20.416.187.416.417v.833c0%20.23-.186.417-.416.417H7.917a.417.417%200%200%201-.417-.417v-.833c0-.23.186-.417.417-.417Zm5.834%200h3.333c.23%200%20.417.187.417.417v.833c0%20.23-.187.417-.417.417H13.75a.417.417%200%200%201-.417-.417v-.833c0-.23.187-.417.417-.417ZM2.083%207.5h3.333c.23%200%20.417.187.417.417v2.5c0%20.23-.186.416-.417.416H2.083a.417.417%200%200%201-.417-.416v-2.5c0-.23.187-.417.417-.417Zm5.833%200h3.334c.23%200%20.416.187.416.417v2.5c0%20.23-.186.416-.416.416H7.917a.417.417%200%200%201-.417-.416v-2.5c0-.23.186-.417.417-.417Zm5.834%200h3.333c.23%200%20.417.187.417.417v2.5c0%20.23-.187.416-.417.416H13.75a.417.417%200%200%201-.417-.416v-2.5c0-.23.187-.417.417-.417ZM2.083%2012.5h3.333c.23%200%20.417.187.417.417v2.5c0%20.23-.186.416-.417.416H2.083a.417.417%200%200%201-.417-.416v-2.5c0-.23.187-.417.417-.417Zm5.833%200h3.334c.23%200%20.416.187.416.417v2.5c0%20.23-.186.416-.416.416H7.917a.417.417%200%200%201-.417-.416v-2.5c0-.23.186-.417.417-.417Zm5.834%200h3.333c.23%200%20.417.187.417.417v2.5c0%20.23-.187.416-.417.416H13.75a.417.417%200%200%201-.417-.416v-2.5c0-.23.187-.417.417-.417Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const iconGeolayers = "data:image/svg+xml,%3csvg%20width='20'%20height='20'%20viewBox='0%200%2020%2020'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20fill-rule='evenodd'%20clip-rule='evenodd'%20d='M3.75%203.947V3.75h8.125l-.818%202.026-.39.965L3.75%203.947Zm0%201.124v5.616l3.61%201.46.964.389.39-.965.391-.966%201.17-2.897L3.75%205.071Zm0%206.74v4.439h3.074l1.11-2.748-4.184-1.69Zm4.197%204.439h8.303v-1.635l-5.604-2.264-.964-.39-.39.966-.39.965H8.9l-.953%202.358Zm8.303-2.759V3.75H13l-1.367%203.381-.39.966-1.171%202.898.966.39%205.212%202.106ZM3.542%202.5A1.042%201.042%200%200%200%202.5%203.542v12.916A1.042%201.042%200%200%200%203.542%2017.5h12.916a1.041%201.041%200%200%200%201.042-1.042V3.542A1.041%201.041%200%200%200%2016.458%202.5H3.542Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const iconMetric = "data:image/svg+xml,%3csvg%20width='20'%20height='20'%20viewBox='0%200%2020%2020'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M2.584%2015.376a.75.75%200%201%200%20.832%201.248l-.832-1.248Zm1.788-.29.416.623-.416-.624Zm3.484-.467.237-.712-.237.712Zm1.41.47-.238.71.237-.71Zm4.464-1.395.6.45-.6-.45Zm1.87-1.244a.75.75%200%201%200-1.2-.9l1.2.9ZM3.416%2016.624l1.372-.915-.832-1.248-1.372.915.832%201.248Zm1.373-.915a3.25%203.25%200%200%201%202.83-.379l.474-1.423a4.75%204.75%200%200%200-4.137.554l.833%201.248Zm2.83-.379%201.409.47.474-1.423-1.409-.47-.474%201.423Zm1.409.47a4.75%204.75%200%200%200%205.302-1.656l-1.2-.9a3.25%203.25%200%200%201-3.628%201.133L9.028%2015.8Zm5.302-1.656%201.27-1.694-1.2-.9-1.27%201.694%201.2.9ZM3.722%2010H2.338V5.816L1.202%206.888V5.696L2.538%204.44h1.184V10Zm1.574.064a.674.674%200%200%201-.496-.2.674.674%200%200%201-.2-.496.683.683%200%200%201%20.696-.704c.192%200%20.355.067.488.2a.67.67%200%200%201%20.208.504.66.66%200%200%201-.208.496.664.664%200%200%201-.488.2ZM10.361%2010H6.53v-.816c.411-.347.766-.653%201.064-.92.3-.267.544-.512.736-.736a2.66%202.66%200%200%200%20.432-.656%201.53%201.53%200%200%200%20.144-.648c0-.31-.082-.547-.248-.712-.165-.165-.41-.248-.736-.248-.154%200-.298.019-.432.056a1.69%201.69%200%200%200-.36.144%201.563%201.563%200%200%200-.288.184%202.45%202.45%200%200%200-.2.176v-.928c.043-.048.107-.101.192-.16.091-.059.206-.115.344-.168.14-.059.302-.107.488-.144.192-.037.414-.056.664-.056.326%200%20.611.043.856.128.251.08.46.197.624.352.171.15.3.33.384.544.086.208.128.443.128.704%200%20.304-.053.59-.16.856a3.057%203.057%200%200%201-.456.76c-.192.24-.429.477-.712.712-.277.23-.589.467-.936.712h2.304V10Zm6.874-4.008-1.288%203.336h-1l-1.28-3.416V10h-1.032V4.44h1.688l1.312%203.384%201.288-3.384h1.736V10h-1.424V5.992Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const iconAnyChart = "data:image/svg+xml,%3csvg%20width='16'%20height='17'%20viewBox='0%200%2016%2017'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20fill-rule='evenodd'%20clip-rule='evenodd'%20d='M.818%203.084a1.545%201.545%200%200%201%201.546-1.545h11.272a1.545%201.545%200%200%201%201.546%201.545v11.273a1.546%201.546%200%200%201-1.546%201.545H2.364a1.546%201.546%200%200%201-1.546-1.545V3.084Zm1.288-.257A.364.364%200%200%200%202%203.084v11.273a.364.364%200%200%200%20.364.363h11.272a.364.364%200%200%200%20.364-.363V3.084a.364.364%200%200%200-.364-.364H2.364a.364.364%200%200%200-.258.107Z'%20fill='currentColor'/%3e%3cpath%20fill-rule='evenodd'%20clip-rule='evenodd'%20d='M8.464%2010.754h-1.37a30.184%2030.184%200%200%201-.005-.36c0-.444.074-.81.22-1.096.147-.286.441-.608.881-.966.44-.359.704-.593.79-.704a.94.94%200%200%200%20.199-.58.977.977%200%200%200-.352-.755c-.235-.21-.55-.314-.948-.314-.383%200-.704.11-.962.328-.257.218-.435.551-.531.999L5%207.134c.04-.641.312-1.185.82-1.633.506-.448%201.17-.671%201.994-.671.867%200%201.556.226%202.068.679.512.453.768.98.768%201.582%200%20.333-.094.648-.282.945-.188.297-.59.702-1.205%201.214-.32.265-.517.478-.594.64-.077.16-.112.448-.105.864ZM7.095%2012.784v-1.51h1.509v1.51h-1.51Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const iconControls = "data:image/svg+xml,%3csvg%20width='20'%20height='20'%20viewBox='0%200%2020%2020'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20opacity='.01'%20fill='currentColor'%20d='M0%200h20v20H0z'/%3e%3cpath%20fill-rule='evenodd'%20clip-rule='evenodd'%20d='M15.125%206.125a1.5%201.5%200%201%201-3%200%201.5%201.5%200%200%201%203%200Zm1.47.977a3.126%203.126%200%200%201-5.932.023h-8.1a.813.813%200%200%201%200-1.625h8a3.126%203.126%200%200%201%206.126.006.82.82%200%200%201%20.096-.006h.652a.813.813%200%200%201%200%201.625h-.652a.815.815%200%200%201-.19-.023ZM5.875%2013.875a1.5%201.5%200%201%200%203%200%201.5%201.5%200%200%200-3%200Zm-1.461%201a3.126%203.126%200%200%200%205.923%200h7.1a.813.813%200%200%200%200-1.625h-7a3.126%203.126%200%200%200-6.124%200h-1.75a.813.813%200%200%200%200%201.625h1.85Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const RELATIONS_CHARTS_ICONS_DICT = {
+  control: iconControls,
+  table: iconFlatTable,
+  widget: iconAnyChart,
+  metric: iconMetric,
+  metric2: iconMetric,
+  ymap: iconGeolayers,
+  markdown: LogoMarkdownIcon,
+  markup: iconMetric,
+  "blank-chart": iconEditorChart,
+  "advanced-chart": iconEditorChart,
+  d3: iconEditorChart
+};
+const DEFAULT_ALIAS_NAMESPACE = "default";
+const DEFAULT_ICON_SIZE = 16;
+const RELATION_TYPES = {
+  ignore: "ignore",
+  input: "input",
+  output: "output",
+  both: "both",
+  unknown: "unknown"
+};
+const TEXT_LIMIT = 20;
+const FULL_RELATIONS = [
+  RELATION_TYPES.both,
+  RELATION_TYPES.input,
+  RELATION_TYPES.output,
+  RELATION_TYPES.ignore
+];
+const INPUT_RELATIONS = [RELATION_TYPES.input, RELATION_TYPES.ignore];
+const OUTPUT_RELATIONS = [RELATION_TYPES.output, RELATION_TYPES.ignore];
+const b$9 = block("dialog-relations-filters");
+const i18n$8 = I18n.keyset("component.dialog-relations.view");
+const DEFAULT_FILTERS = ["input", "output", "none"];
+const getFilterProps = ({
+  currentType,
+  filters
+}) => {
+  const isActive = filters.includes(currentType);
+  return {
+    isActive,
+    buttonType: isActive ? "normal" : "outlined"
+  };
+};
+const Filters = ({
+  onChangeInput,
+  onChangeButtons
+}) => {
+  const [searchValue, setSearchValue] = React__default.useState("");
+  const [activeFilters, setActiveFilters] = React__default.useState([]);
+  const handleSearchValue = React__default.useCallback(
+    (value) => {
+      onChangeInput(value);
+      setSearchValue(value);
+    },
+    [onChangeInput]
+  );
+  const handleButtonClick = React__default.useCallback(
+    (type) => {
+      let newFilters = [];
+      if (activeFilters.includes(type)) {
+        newFilters = activeFilters.filter((item) => item !== type);
+      } else {
+        newFilters = [...activeFilters, type];
+      }
+      setActiveFilters(newFilters);
+      onChangeButtons(newFilters);
+    },
+    [activeFilters, onChangeButtons]
+  );
+  const inputButtonProps = getFilterProps({ currentType: "input", filters: activeFilters });
+  const outputButtonProps = getFilterProps({ currentType: "output", filters: activeFilters });
+  const noneButtonProps = getFilterProps({ currentType: "none", filters: activeFilters });
+  return /* @__PURE__ */ jsxs("div", { className: b$9("top"), children: [
+    /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        value: searchValue,
+        onUpdate: handleSearchValue,
+        placeholder: i18n$8("label_placeholder-search"),
+        className: b$9("search"),
+        hasClear: true
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        view: inputButtonProps.buttonType,
+        className: b$9("button"),
+        selected: inputButtonProps.isActive,
+        onClick: () => handleButtonClick("input"),
+        children: i18n$8("button_incoming")
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        view: outputButtonProps.buttonType,
+        className: b$9("button"),
+        selected: outputButtonProps.isActive,
+        onClick: () => handleButtonClick("output"),
+        children: i18n$8("button_outcoming")
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        view: noneButtonProps.buttonType,
+        className: b$9("button"),
+        selected: noneButtonProps.isActive,
+        onClick: () => handleButtonClick("none"),
+        children: i18n$8("button_not-linked")
+      }
+    )
+  ] });
+};
+const mapFieldsListGuid = (list, result) => {
+  list.forEach((listItem) => {
+    if (!result[listItem.guid]) {
+      result[listItem.guid] = listItem.title || "";
+    }
+  });
+};
+const getDatasetItemFlatFields = (data) => {
+  if (!data) {
+    return {};
+  }
+  let result = {};
+  if (Array.isArray(data.fields)) {
+    mapFieldsListGuid(data.fields, result);
+  } else {
+    result = { ...data.fields };
+  }
+  if (data.fieldsList) {
+    mapFieldsListGuid(data.fieldsList, result);
+  }
+  return result;
+};
+const getDatasetsFlatItems = (datasets) => {
+  if (!datasets) {
+    return {};
+  }
+  let result = {};
+  datasets.forEach((item) => {
+    const fields = getDatasetItemFlatFields(item);
+    result = { ...result, ...fields };
+  });
+  return result;
+};
+const getDatasetsListWithFlatFields = (datasets) => {
+  if (!datasets) {
+    return {};
+  }
+  const flatDatasetFields = {};
+  for (const [id, data] of Object.entries(datasets)) {
+    flatDatasetFields[id] = data.fields.reduce(
+      (result, { guid, title }) => {
+        result[guid] = title;
+        return result;
+      },
+      {}
+    );
+  }
+  return flatDatasetFields;
+};
+const getMappedConnectedControlField = ({
+  item,
+  datasets,
+  itemDefaults
+}) => {
+  if (!isControl(item)) {
+    return null;
+  }
+  if (item?.datasets?.length && !item.isQL) {
+    return Object.keys(itemDefaults || item.defaultParams).map((paramItem) => {
+      const allFields = getDatasetsFlatItems(item.datasets);
+      return allFields[paramItem] || "";
+    }).filter(Boolean);
+  } else {
+    const datasetFlatFields = getDatasetsListWithFlatFields(datasets);
+    if (datasetFlatFields && item?.datasetId && datasetFlatFields[item?.datasetId]) {
+      return Object.keys(itemDefaults || item.defaultParams).map(
+        (paramItem) => datasetFlatFields[item.datasetId] && datasetFlatFields[item.datasetId][paramItem]
+      ).filter(Boolean);
+    }
+  }
+  return null;
+};
+const isControl = (item) => item.type === DASH_WIDGET_TYPES.CONTROL;
+const isManualControl = (item) => isControl(item) && !item.datasetId && !item.chartId;
+const isDatasetControl = (item) => isControl(item) && item.datasetId;
+const isExternalControl = (item) => isControl(item) && item.chartId;
+const hasCommonUsedParamsWithDefaults = (widgetParams, usedParams) => {
+  return Boolean(intersection(Object.keys(widgetParams || {}), usedParams).length);
+};
+const hasCommonDefaultsWithDefaults = (widgetParams, itemWidgetParams) => {
+  return Boolean(
+    intersection(Object.keys(widgetParams || {}), Object.keys(itemWidgetParams || {})).length
+  );
+};
+const getControlToControlRelations = ({
+  byUsedParams,
+  relationType,
+  relations,
+  widget,
+  row,
+  datasets
+}) => {
+  let newRelationType = relationType;
+  let availableRelations = [];
+  let byFields = [];
+  let hasDataset = false;
+  let forceAddAlias = false;
+  let hasRelation = false;
+  const isIndirectRelation = !relations.isIgnored && !relations.isIgnoring;
+  if (isManualControl(widget) && isManualControl(row)) {
+    if (relations.byAliases.length || byUsedParams.length) {
+      newRelationType = relationType || getDefaultTypeByIgnore(relations);
+    } else {
+      newRelationType = RELATION_TYPES.ignore;
+      forceAddAlias = true;
+    }
+    availableRelations = [...FULL_RELATIONS];
+  } else if (isDatasetControl(widget) && isManualControl(row) || isDatasetControl(row) && isManualControl(widget)) {
+    hasDataset = true;
+    byFields = getMappedConnectedControlField({
+      item: isDatasetControl(widget) ? widget : row,
+      itemDefaults: isDatasetControl(widget) ? row.defaultParams : widget.defaultParams,
+      datasets
+    }) || byUsedParams;
+    if (relations.byAliases.length || byUsedParams.length) {
+      newRelationType = relationType || getDefaultTypeByIgnore(relations);
+    } else if (isIndirectRelation && relations.indirectAliases.length) {
+      newRelationType = RELATION_TYPES.unknown;
+      forceAddAlias = true;
+    } else {
+      newRelationType = RELATION_TYPES.ignore;
+      forceAddAlias = true;
+    }
+    availableRelations = [...FULL_RELATIONS];
+  } else if (isManualControl(widget) && isExternalControl(row) || isManualControl(row) && isExternalControl(widget)) {
+    if (relations.byAliases.length) {
+      newRelationType = relationType || getDefaultTypeByIgnore(relations);
+      availableRelations = [...FULL_RELATIONS];
+    } else if (isExternalControl(widget)) {
+      hasRelation = hasCommonUsedParamsWithDefaults(
+        widget.widgetParams || {},
+        row.usedParams || []
+      );
+      if (hasRelation) {
+        newRelationType = relationType || getDefaultTypeByIgnore(relations);
+        availableRelations = [...FULL_RELATIONS];
+      } else {
+        newRelationType = relationType || RELATION_TYPES.input;
+        availableRelations = [...INPUT_RELATIONS];
+      }
+    } else {
+      hasRelation = hasCommonUsedParamsWithDefaults(
+        row.widgetParams || {},
+        widget.usedParams || []
+      );
+      if (hasRelation) {
+        newRelationType = relationType || getDefaultTypeByIgnore(relations);
+        availableRelations = [...FULL_RELATIONS];
+      } else {
+        newRelationType = relationType || RELATION_TYPES.output;
+        availableRelations = [...OUTPUT_RELATIONS];
+      }
+    }
+  } else if (isDatasetControl(widget) && isDatasetControl(row)) {
+    if (relations.byAliases.length) {
+      newRelationType = relationType || getDefaultTypeByIgnore(relations);
+    } else if (widget.datasetId === row.datasetId) {
+      newRelationType = relationType || getDefaultTypeByIgnore(relations);
+      byFields = [];
+      hasDataset = true;
+    } else {
+      const commonUsedParamsFields = intersection(
+        widget.usedParams || [],
+        row.usedParams || []
+      );
+      if (commonUsedParamsFields.length) {
+        newRelationType = relationType || getDefaultTypeByIgnore(relations);
+        byFields = [];
+      } else {
+        newRelationType = RELATION_TYPES.ignore;
+        forceAddAlias = true;
+      }
+    }
+    availableRelations = [...FULL_RELATIONS];
+  } else if (isDatasetControl(widget) && isExternalControl(row) || isDatasetControl(row) && isExternalControl(widget)) {
+    if (relations.byAliases.length) {
+      newRelationType = relationType || getDefaultTypeByIgnore(relations);
+      availableRelations = [...FULL_RELATIONS];
+    } else if (isExternalControl(widget)) {
+      hasRelation = hasCommonUsedParamsWithDefaults(
+        widget.widgetParams || {},
+        row.usedParams || []
+      );
+      if (hasRelation) {
+        newRelationType = relationType || getDefaultTypeByIgnore(relations);
+        availableRelations = [...FULL_RELATIONS];
+        hasDataset = true;
+        byFields = getMappedConnectedControlField({
+          item: row,
+          datasets
+        }) || [];
+      } else {
+        newRelationType = relationType || RELATION_TYPES.input;
+        availableRelations = [...INPUT_RELATIONS];
+      }
+    } else {
+      hasRelation = hasCommonUsedParamsWithDefaults(
+        row.widgetParams || {},
+        widget.usedParams || []
+      );
+      if (hasRelation) {
+        newRelationType = relationType || getDefaultTypeByIgnore(relations);
+        availableRelations = [...FULL_RELATIONS];
+        hasDataset = true;
+        byFields = getMappedConnectedControlField({
+          item: widget,
+          datasets
+        }) || [];
+      } else {
+        newRelationType = relationType || RELATION_TYPES.output;
+        availableRelations = [...OUTPUT_RELATIONS];
+      }
+    }
+  } else if (isExternalControl(widget) && isExternalControl(row)) {
+    hasRelation = hasCommonDefaultsWithDefaults(
+      row.widgetParams || {},
+      widget.widgetParams || {}
+    );
+    const hasWigetParams = Object.keys(widget.widgetParams || {}).length;
+    const hasRowParams = Object.keys(row.widgetParams || {}).length;
+    if (relations.byAliases.length && hasWigetParams && hasRowParams || hasRelation) {
+      newRelationType = relationType || getDefaultTypeByIgnore(relations);
+      availableRelations = [...FULL_RELATIONS];
+    } else if (hasWigetParams && hasRowParams) {
+      newRelationType = RELATION_TYPES.unknown;
+      availableRelations = [...FULL_RELATIONS];
+      forceAddAlias = true;
+    } else if (hasWigetParams) {
+      newRelationType = OUTPUT_RELATIONS.includes(relationType) ? relationType : RELATION_TYPES.output;
+      availableRelations = [...OUTPUT_RELATIONS];
+    } else if (hasRowParams) {
+      newRelationType = INPUT_RELATIONS.includes(relationType) ? relationType : RELATION_TYPES.input;
+      availableRelations = [...INPUT_RELATIONS];
+    } else {
+      newRelationType = relationType || RELATION_TYPES.ignore;
+      availableRelations = [...FULL_RELATIONS];
+      forceAddAlias = true;
+    }
+  }
+  return {
+    relationType: newRelationType,
+    availableRelations,
+    byFields,
+    hasDataset,
+    forceAddAlias,
+    hasRelation
+  };
+};
+const isEditorChart = (item) => item.isEditor && !isControl(item) && item.chartId;
+const getControlToChartRelations = ({
+  relationType,
+  widget,
+  row,
+  relations,
+  datasets
+}) => {
+  let availableRelations = [...OUTPUT_RELATIONS];
+  let newRelationType = relationType;
+  const isItemFilteringChart = Boolean(
+    row.type in DASH_FILTERING_CHARTS_WIDGET_TYPES && row.enableFiltering
+  );
+  let hasRelation = false;
+  let forceAddAlias = false;
+  let byFields = [];
+  if (relations.byAliases.length) {
+    if (isItemFilteringChart) {
+      newRelationType = relationType || getDefaultTypeByIgnore(relations);
+      availableRelations = [...FULL_RELATIONS];
+    } else {
+      newRelationType = relationType || RELATION_TYPES.output;
+      if (!OUTPUT_RELATIONS.includes(newRelationType)) {
+        newRelationType = RELATION_TYPES.output;
+      }
+      availableRelations = [...OUTPUT_RELATIONS];
+    }
+  } else if (isExternalControl(widget)) {
+    hasRelation = hasCommonUsedParamsWithDefaults(
+      widget.widgetParams || {},
+      row.usedParams || []
+    );
+    if (hasRelation) {
+      newRelationType = relationType || RELATION_TYPES.output;
+    } else if (isEditorChart(row)) {
+      newRelationType = relationType || RELATION_TYPES.unknown;
+      forceAddAlias = true;
+    } else {
+      newRelationType = RELATION_TYPES.ignore;
+    }
+    if (isItemFilteringChart) {
+      availableRelations = [...FULL_RELATIONS];
+    } else {
+      if (!OUTPUT_RELATIONS.includes(newRelationType)) {
+        newRelationType = RELATION_TYPES.output;
+      }
+      availableRelations = [...OUTPUT_RELATIONS];
+    }
+  } else {
+    const commonUsedParamsFields = intersection(widget.usedParams || [], row.usedParams || []);
+    if (commonUsedParamsFields.length) {
+      newRelationType = relationType || RELATION_TYPES.output;
+      if (isDatasetControl(widget)) {
+        byFields = getMappedConnectedControlField({ item: widget, datasets }) || [];
+      }
+      if (isItemFilteringChart) {
+        availableRelations = [...FULL_RELATIONS];
+      } else {
+        if (!OUTPUT_RELATIONS.includes(newRelationType)) {
+          newRelationType = RELATION_TYPES.output;
+        }
+        availableRelations = [...OUTPUT_RELATIONS];
+      }
+    } else {
+      newRelationType = relationType || RELATION_TYPES.unknown;
+      if (isItemFilteringChart) {
+        availableRelations = [...FULL_RELATIONS];
+      }
+      forceAddAlias = true;
+    }
+  }
+  return {
+    relationType: newRelationType,
+    availableRelations,
+    forceAddAlias,
+    byFields
+  };
+};
+const getChartToControlRelations = ({
+  relationType,
+  widget,
+  row,
+  relations,
+  datasets
+}) => {
+  let newRelationType = relationType;
+  let availableRelations = [...INPUT_RELATIONS];
+  const isCurrentFilteringChart = Boolean(
+    widget.type in DASH_FILTERING_CHARTS_WIDGET_TYPES && widget.enableFiltering
+  );
+  let forceAddAlias = false;
+  let hasRelation = false;
+  let byFields = [];
+  if (relations.byAliases.length) {
+    if (isCurrentFilteringChart) {
+      newRelationType = relationType || getDefaultTypeByIgnore(relations);
+      availableRelations = [...FULL_RELATIONS];
+    } else {
+      newRelationType = relationType || RELATION_TYPES.input;
+      if (!INPUT_RELATIONS.includes(newRelationType)) {
+        newRelationType = RELATION_TYPES.input;
+      }
+      availableRelations = [...INPUT_RELATIONS];
+    }
+  } else if (isExternalControl(row)) {
+    hasRelation = hasCommonUsedParamsWithDefaults(
+      row.widgetParams || {},
+      widget.usedParams || []
+    );
+    if (hasRelation) {
+      newRelationType = relationType || RELATION_TYPES.input;
+    } else if (isEditorChart(widget)) {
+      newRelationType = relationType || RELATION_TYPES.unknown;
+      forceAddAlias = true;
+    } else {
+      newRelationType = RELATION_TYPES.ignore;
+    }
+    if (isCurrentFilteringChart) {
+      availableRelations = [...FULL_RELATIONS];
+    } else {
+      if (!INPUT_RELATIONS.includes(newRelationType)) {
+        newRelationType = RELATION_TYPES.input;
+      }
+      availableRelations = [...INPUT_RELATIONS];
+    }
+  } else {
+    const commonUsedParamsFields = intersection(row.usedParams || [], widget.usedParams || []);
+    if (commonUsedParamsFields.length) {
+      newRelationType = relationType || RELATION_TYPES.input;
+      if (isDatasetControl(row)) {
+        byFields = getMappedConnectedControlField({ item: row, datasets }) || [];
+      }
+      if (isCurrentFilteringChart) {
+        availableRelations = [...FULL_RELATIONS];
+      } else {
+        if (!INPUT_RELATIONS.includes(newRelationType)) {
+          newRelationType = RELATION_TYPES.input;
+        }
+        availableRelations = [...INPUT_RELATIONS];
+      }
+    } else {
+      newRelationType = relationType || RELATION_TYPES.unknown;
+      if (isCurrentFilteringChart) {
+        availableRelations = [...FULL_RELATIONS];
+      }
+      forceAddAlias = true;
+    }
+  }
+  return {
+    relationType: newRelationType,
+    availableRelations,
+    forceAddAlias,
+    byFields
+  };
+};
+const getChartAndControlRelations = (args) => {
+  const { isCurrentControl, isItemControl, relationType, row, widget, relations, datasets } = args;
+  let availableRelations = [];
+  let newRelationType = relationType;
+  let forceAddAlias = false;
+  let byFields = [];
+  if (!isCurrentControl && isItemControl) {
+    const chartToControlRelation = getChartToControlRelations({
+      relationType,
+      widget,
+      row,
+      relations,
+      datasets
+    });
+    newRelationType = chartToControlRelation.relationType;
+    availableRelations = chartToControlRelation.availableRelations;
+    forceAddAlias = chartToControlRelation.forceAddAlias;
+    byFields = chartToControlRelation.byFields;
+  } else if (!isItemControl && isCurrentControl) {
+    const controlToChartRelation = getControlToChartRelations({
+      relationType,
+      widget,
+      row,
+      relations,
+      datasets
+    });
+    newRelationType = controlToChartRelation.relationType;
+    availableRelations = controlToChartRelation.availableRelations;
+    forceAddAlias = controlToChartRelation.forceAddAlias;
+    byFields = controlToChartRelation.byFields;
+  }
+  return {
+    relationType: newRelationType,
+    availableRelations,
+    forceAddAlias,
+    byFields
+  };
+};
+const getChartToChartRelations = ({
+  widget,
+  row,
+  relationType,
+  relations
+}) => {
+  const isCurrentFilteringChart = Boolean(
+    widget.type in DASH_FILTERING_CHARTS_WIDGET_TYPES && widget.enableFiltering
+  );
+  const isItemFilteringChart = Boolean(
+    row.type in DASH_FILTERING_CHARTS_WIDGET_TYPES && row.enableFiltering
+  );
+  let availableRelations = [];
+  let hasDataset = false;
+  let byFields = [];
+  let newRelationType = relationType || RELATION_TYPES.ignore;
+  if (isCurrentFilteringChart && !isItemFilteringChart) {
+    newRelationType = relationType || RELATION_TYPES.output;
+    if (!OUTPUT_RELATIONS.includes(newRelationType)) {
+      newRelationType = RELATION_TYPES.output;
+    }
+    availableRelations = [...OUTPUT_RELATIONS];
+    if (widget.isWizard) {
+      hasDataset = true;
+      byFields = [];
+    }
+  } else if (!isCurrentFilteringChart && isItemFilteringChart) {
+    newRelationType = relationType || RELATION_TYPES.input;
+    if (!INPUT_RELATIONS.includes(newRelationType)) {
+      newRelationType = RELATION_TYPES.input;
+    }
+    availableRelations.push(RELATION_TYPES.input, RELATION_TYPES.ignore);
+    if (row.isWizard) {
+      hasDataset = true;
+      byFields = [];
+    }
+  } else if (isCurrentFilteringChart && isItemFilteringChart) {
+    newRelationType = relationType || getDefaultTypeByIgnore(relations);
+    availableRelations = [...FULL_RELATIONS];
+    if (widget.isWizard || row.isWizard) {
+      hasDataset = true;
+      byFields = [];
+    }
+  }
+  return {
+    relationType: newRelationType,
+    availableRelations,
+    hasDataset,
+    byFields
+  };
+};
+const getPreparedMetaData = (data, dashkitData) => {
+  if (!data || !data?.length || !dashkitData) {
+    return {
+      metaData: [],
+      datasetsList: {},
+      entriesList: [],
+      controlsList: []
+    };
+  }
+  const config = dashkitData.props.config;
+  const configItems = {};
+  const allItems = getAllTabItems(config);
+  allItems.forEach((item) => {
+    configItems[item.id] = item.namespace;
+  });
+  const metaDataWithNamespaces = data.reduce(
+    (list, item) => list.concat(item),
+    []
+  ).map((item) => ({
+    ...item,
+    namespace: configItems[item.layoutId] || ""
+  }));
+  const datasetsList = {};
+  const controlsList = [];
+  metaDataWithNamespaces.forEach((item) => {
+    if (item.datasets?.length) {
+      item.datasets.forEach((datasetItem) => {
+        if (datasetItem.id) {
+          datasetsList[datasetItem.id] = {
+            fields: datasetItem.fieldsList
+          };
+        }
+      });
+    }
+    if (item?.type === DashTabItemType.Control && item?.sourceType !== DashTabItemControlSourceType.Dataset) {
+      controlsList.push(item?.widgetId);
+    }
+  });
+  const entriesList = [
+    ...new Set(metaDataWithNamespaces.map((item) => item.entryId).filter(Boolean))
+  ];
+  return {
+    metaData: metaDataWithNamespaces,
+    datasetsList,
+    entriesList,
+    controlsList
+  };
+};
+const getMetaDataWithDatasetInfo = ({
+  metaData,
+  entriesDatasetsFields,
+  datasetsList
+}) => {
+  const entriesWithDatasetsFields = entriesDatasetsFields.filter(
+    (item) => Boolean(item.datasetFields?.length)
+  );
+  const res = (metaData || []).map((item) => {
+    const itemWithDataset = { ...item };
+    const entryWithDataset = entriesWithDatasetsFields.find(
+      (entryItem) => entryItem.entryId === itemWithDataset.entryId
+    );
+    if (!entryWithDataset) {
+      return itemWithDataset;
+    }
+    const { type, datasetId, datasetName, datasetFields, visualizationType } = entryWithDataset;
+    const key = datasetId;
+    if (datasetFields) {
+      datasetsList[key] = datasetsList[key] || {};
+      datasetsList[key].name = datasetName || "";
+      datasetsList[key].fields = datasetFields.map((fieldItem) => ({
+        title: fieldItem.title,
+        guid: fieldItem.guid,
+        dataType: fieldItem.dataType || fieldItem.type || ""
+      }));
+    }
+    if (datasetId && datasetsList[datasetId]) {
+      const fields = datasetsList[datasetId].fields;
+      itemWithDataset.usedParams = Array.isArray(fields) ? fields.map((fieldItem) => fieldItem.guid) : Object.keys(fields);
+      item.datasets?.find(({ id }) => id === datasetId)?.fieldsList.forEach(({ guid }) => {
+        if (!itemWithDataset.usedParams?.includes(guid)) {
+          itemWithDataset.usedParams?.push(guid);
+        }
+      });
+      itemWithDataset.datasets = item.datasets?.length ? item.datasets.map((datasetItem) => ({
+        ...datasetItem,
+        name: datasetsList[datasetItem.id]?.name
+      })) : [
+        {
+          id: datasetId,
+          fieldsList: datasetFields || [],
+          fields: datasetsList[key].fields,
+          name: datasetsList[key].name
+        }
+      ];
+      itemWithDataset.type = item.type || type;
+      itemWithDataset.enableFiltering = item.enableFiltering || false;
+    }
+    if (visualizationType) {
+      itemWithDataset.visualizationType = visualizationType;
+    }
+    return itemWithDataset;
+  });
+  return res;
+};
+const showInRelation = (currentItem, rowItem) => {
+  const isItemControl = isControl(rowItem);
+  const isCurrentChartAcceptFilter = currentItem.type in DASH_ACCEPT_FILTERING_CHARTS_WIDGET_TYPES;
+  const isItemChartAcceptFilter = rowItem.type in DASH_ACCEPT_FILTERING_CHARTS_WIDGET_TYPES;
+  const isCurrentFilteringChart = currentItem.type in DASH_FILTERING_CHARTS_WIDGET_TYPES && currentItem.enableFiltering;
+  const isItemFilteringChart = rowItem.type in DASH_FILTERING_CHARTS_WIDGET_TYPES && rowItem.enableFiltering;
+  if (currentItem.loadError || rowItem.loadError || currentItem.type === null && (currentItem.chartId || currentItem.datasetId) || rowItem.type === null && (rowItem.chartId || rowItem.datasetId)) {
+    return true;
+  } else if (isControl(currentItem)) {
+    if (isItemControl || isItemChartAcceptFilter) {
+      return true;
+    }
+  } else if (isCurrentFilteringChart) {
+    if (isItemControl || isItemChartAcceptFilter) {
+      return true;
+    }
+  } else if (isCurrentChartAcceptFilter) {
+    if (isItemControl || isItemFilteringChart) {
+      return true;
+    }
+  }
+  return false;
+};
+const getCurrentNamespaceItems = ({
+  metaItems,
+  id
+}) => {
+  if (!metaItems || !metaItems.length) {
+    return [];
+  }
+  if (!id) {
+    return metaItems || [];
+  }
+  return metaItems.filter((item) => {
+    const itemId = item.itemId || item.widgetId;
+    return itemId !== id && item.namespace === DEFAULT_ALIAS_NAMESPACE;
+  });
+};
+const getDefaultTypeByIgnore = (relations) => {
+  let relationType = RELATION_TYPES.both;
+  if (relations.isIgnored || relations.isIgnoring) {
+    relationType = relations.isIgnored ? RELATION_TYPES.output : RELATION_TYPES.input;
+  }
+  return relationType;
+};
+const getRelationTypeByIgnores = ({
+  relations,
+  loadError,
+  hasRelation
+}) => {
+  let relationType = "";
+  if (relations.isIgnored && relations.isIgnoring) {
+    relationType = RELATION_TYPES.ignore;
+  } else if (loadError) {
+    relationType = RELATION_TYPES.unknown;
+  } else if (hasRelation) {
+    relationType = getDefaultTypeByIgnore(relations);
+  }
+  return relationType;
+};
+const getItemsRelations = ({
+  relations,
+  widgetMeta,
+  row,
+  datasets
+}) => {
+  const isCurrentControl = isControl(widgetMeta);
+  const isItemControl = isControl(row);
+  const byUsedParams = relations.byUsedParams;
+  let relationType = getRelationTypeByIgnores({
+    loadError: Boolean(widgetMeta.loadError || row.loadError),
+    relations,
+    hasRelation: Boolean(byUsedParams.length || relations.byAliases.length)
+  });
+  let byFields = [];
+  let hasDataset = false;
+  let forceAddAlias = false;
+  let availableRelations = [];
+  if (widgetMeta.loadError || row.loadError) {
+    availableRelations.push(RELATION_TYPES.unknown, RELATION_TYPES.ignore);
+  } else if (isItemControl && isCurrentControl) {
+    const resultRelations = getControlToControlRelations({
+      relationType,
+      widget: widgetMeta,
+      row,
+      byUsedParams,
+      relations,
+      datasets
+    });
+    relationType = resultRelations.relationType;
+    availableRelations = resultRelations.availableRelations;
+    byFields = resultRelations.byFields;
+    hasDataset = resultRelations.hasDataset;
+    forceAddAlias = resultRelations.forceAddAlias;
+  } else if (!isItemControl && !isCurrentControl) {
+    const resultRelations = getChartToChartRelations({
+      widget: widgetMeta,
+      row,
+      relationType,
+      relations
+    });
+    relationType = resultRelations.relationType;
+    availableRelations = resultRelations.availableRelations;
+    hasDataset = resultRelations.hasDataset;
+  } else {
+    const resultRelations = getChartAndControlRelations({
+      relations,
+      relationType,
+      isCurrentControl,
+      isItemControl,
+      widget: widgetMeta,
+      row,
+      datasets
+    });
+    relationType = resultRelations.relationType;
+    availableRelations = resultRelations.availableRelations;
+    forceAddAlias = resultRelations.forceAddAlias;
+    byFields = resultRelations.byFields;
+  }
+  if (!relationType) {
+    relationType = RELATION_TYPES.unknown;
+  }
+  return {
+    byUsedParams,
+    byAliases: relations.byAliases,
+    indirectAliases: relations.indirectAliases,
+    isIgnoring: relations.isIgnoring,
+    isIgnored: relations.isIgnored,
+    type: relationType,
+    available: availableRelations,
+    byFields: byFields || [],
+    hasDataset,
+    forceAddAlias
+  };
+};
+const getNormalizedUsedParams = (item) => {
+  if (isExternalControl(item)) {
+    return Object.keys(item.widgetParams || {});
+  }
+  return item.usedParams;
+};
+const getByUsedParams = (args) => {
+  const { widget, row } = args;
+  const rowUsedParams = getNormalizedUsedParams(row) || [];
+  const widgetUsedParams = getNormalizedUsedParams(widget) || [];
+  return intersection(rowUsedParams, widgetUsedParams);
+};
+const getRelationsInfo = (args) => {
+  const { aliases, connections, datasets, widget, row } = args;
+  const byUsedParams = getByUsedParams({ widget, row });
+  let byAliases = [];
+  const indirectAliases = [];
+  const rowId = row.itemId || row.widgetId;
+  const currentId = widget.itemId || widget.widgetId;
+  const ignoreConntections = connections.filter(({ kind }) => kind === CONNECTION_KIND.IGNORE);
+  const isIgnored = ignoreConntections.some(({ from, to }) => from === currentId && to === rowId);
+  const isIgnoring = ignoreConntections.some(({ from, to }) => from === rowId && to === currentId);
+  const isIndirectRelation = !isIgnored && !isIgnoring;
+  if (aliases[DEFAULT_ALIAS_NAMESPACE]?.length) {
+    byAliases = aliases[DEFAULT_ALIAS_NAMESPACE].filter((aliasArr) => {
+      if (!row.usedParams?.length && !isIndirectRelation) {
+        return false;
+      }
+      const rowInAlias = intersection(row.usedParams, aliasArr);
+      const widgetInAlias = intersection(widget.usedParams, aliasArr);
+      if (rowInAlias.length || widgetInAlias.length) {
+        indirectAliases.push(aliasArr);
+      }
+      if (!rowInAlias.length || !widgetInAlias.length) {
+        return false;
+      }
+      return rowInAlias;
+    });
+  }
+  return getItemsRelations({
+    relations: {
+      byUsedParams,
+      byAliases,
+      indirectAliases,
+      isIgnoring,
+      isIgnored,
+      hasDataset: false
+    },
+    widgetMeta: widget,
+    row,
+    datasets
+  });
+};
+const getRelationsData = ({
+  metaData,
+  widgetMeta,
+  aliases,
+  connections,
+  datasets
+}) => {
+  if (!metaData || !metaData.length || !widgetMeta) {
+    return [];
+  }
+  const currentId = widgetMeta.itemId || widgetMeta.widgetId;
+  const metaItems = getCurrentNamespaceItems({
+    metaItems: metaData,
+    id: currentId
+  });
+  const relationsItems = [];
+  metaItems.filter((item) => {
+    const id = item.itemId || item.widgetId;
+    return id !== currentId && showInRelation(widgetMeta, item);
+  }).forEach((item) => {
+    const relations = getRelationsInfo({
+      aliases,
+      connections,
+      datasets,
+      widget: widgetMeta,
+      row: item
+    });
+    relationsItems.push({
+      ...item,
+      relations
+    });
+  });
+  return relationsItems;
+};
+const getCurrentWidgetTabShortInfo = (data, widget, tabId) => {
+  if (widget.type === DashTabItemType.Control || widget.type === DashTabItemType.GroupControl) {
+    return widget;
+  }
+  if (!data || widget.type !== DashTabItemType.Widget) {
+    return null;
+  }
+  const currentPlugin = data.metaRef?.current?.pluginsRefs?.find(
+    (item) => item?.props.id === widget.id
+  );
+  const currentWidgetId = currentPlugin?.chartKitRef?.current?.props.id || currentPlugin?.getCurrentTabChartId?.();
+  const res = currentPlugin?.props.data.tabs.find(
+    (item) => (item.id === tabId || !tabId) && item.chartId === currentWidgetId
+  );
+  if (res) {
+    return { ...res, namespace: currentPlugin.props.namespace };
+  }
+  return res;
+};
+const getCurrentWidgetMeta = ({
+  metaData,
+  dashkitData,
+  widget,
+  itemId,
+  tabId
+}) => {
+  if (itemId) {
+    return metaData?.find((item) => item.itemId === itemId) || {};
+  }
+  const tabInfo = getCurrentWidgetTabShortInfo(dashkitData, widget, tabId);
+  return metaData?.find((item) => item.widgetId === tabInfo?.id) || {};
+};
+const getMappedFilters = (items) => {
+  const mapped = {
+    ignore: false,
+    input: false,
+    output: false,
+    both: false,
+    unknown: false
+  };
+  const preparedItems = items.length > 0 ? items : DEFAULT_FILTERS;
+  preparedItems.forEach((item) => {
+    switch (item) {
+      case "none":
+        mapped.ignore = true;
+        mapped.unknown = true;
+        break;
+      case "input":
+        mapped.input = true;
+        mapped.both = true;
+        break;
+      case "output":
+        mapped.output = true;
+        mapped.both = true;
+        break;
+    }
+  });
+  return mapped;
+};
+const getChangedRelations = (items, changed, currentWidgetId) => {
+  return items.map((item) => {
+    const newItem = {
+      ...item
+    };
+    const id = item.itemId || item.widgetId;
+    if (changed && changed[currentWidgetId] && changed[currentWidgetId][id]) {
+      newItem.relations = {
+        ...item.relations,
+        type: changed[currentWidgetId][id]
+      };
+    }
+    return newItem;
+  });
+};
+const b$8 = block("dialog-relations");
+const getIconByVisualizationId = ({
+  visualizationId,
+  iconSize,
+  className
+}) => {
+  const visualization = VISUALIZATIONS_BY_ID[visualizationId];
+  return visualization ? /* @__PURE__ */ jsx(
+    IconById,
+    {
+      id: visualization.iconProps.id,
+      size: iconSize || DEFAULT_ICON_SIZE,
+      className: `${className} ${b$8("icon-visualization")}`
+    }
+  ) : /* @__PURE__ */ jsx(
+    Icon,
+    {
+      data: RELATIONS_CHARTS_ICONS_DICT.widget,
+      size: iconSize || DEFAULT_ICON_SIZE,
+      className
+    }
+  );
+};
+const getRelationsIcon = (widgetMeta, className) => {
+  if (!widgetMeta) {
+    return null;
+  }
+  if (widgetMeta.visualizationType) {
+    return getIconByVisualizationId({
+      visualizationId: widgetMeta.visualizationType,
+      className
+    });
+  }
+  const iconData = widgetMeta.type === DashTabItemType.Control ? RELATIONS_CHARTS_ICONS_DICT.control : RELATIONS_CHARTS_ICONS_DICT[widgetMeta.type] || RELATIONS_CHARTS_ICONS_DICT.widget;
+  return /* @__PURE__ */ jsx(Icon, { data: iconData, size: DEFAULT_ICON_SIZE, className });
+};
+const getChangedConnections = ({
+  items,
+  widgetId,
+  changedId,
+  changedType
+}) => {
+  const relationFromWidgetToRow = {
+    from: widgetId,
+    kind: RELATION_TYPES.ignore,
+    to: changedId
+  };
+  const relationFromRowToWidget = {
+    from: changedId,
+    kind: RELATION_TYPES.ignore,
+    to: widgetId
+  };
+  const connectionsWithoutCurrentLink = items.filter(
+    (item) => item.kind === RELATION_TYPES.ignore && !(changedId === item.from && widgetId === item.to) && !(changedId === item.to && widgetId === item.from)
+  );
+  let result = [];
+  switch (changedType) {
+    case RELATION_TYPES.ignore: {
+      result = connectionsWithoutCurrentLink.concat([
+        relationFromWidgetToRow,
+        relationFromRowToWidget
+      ]);
+      break;
+    }
+    case RELATION_TYPES.input: {
+      result = connectionsWithoutCurrentLink.concat([relationFromRowToWidget]);
+      break;
+    }
+    case RELATION_TYPES.output: {
+      result = connectionsWithoutCurrentLink.concat([relationFromWidgetToRow]);
+      break;
+    }
+    default:
+      result = connectionsWithoutCurrentLink;
+  }
+  return result;
+};
+const getUpdatedRelations = (items, changed) => {
+  let updatedItems = [...items];
+  for (const id of Object.keys(changed)) {
+    for (const [key, type] of Object.entries(changed[id])) {
+      updatedItems = getChangedConnections({
+        items: updatedItems,
+        widgetId: id,
+        changedId: key,
+        changedType: type
+      });
+    }
+  }
+  return updatedItems;
+};
+const getRelationsForSave = ({
+  changed,
+  dashkitData
+}) => {
+  if (!dashkitData || !changed || isEmpty(changed)) {
+    return null;
+  }
+  const { connections } = dashkitData.props.config;
+  return getUpdatedRelations(connections, changed);
+};
+const appendUniq = (first, second, alias) => {
+  const uniqSet = /* @__PURE__ */ new Set([first, second]);
+  alias.forEach((key) => uniqSet.add(key));
+  return Array.from(uniqSet);
+};
+const concatUniq = (left, right) => {
+  const uniqSet = /* @__PURE__ */ new Set();
+  left.forEach((key) => uniqSet.add(key));
+  right.forEach((key) => uniqSet.add(key));
+  return Array.from(uniqSet);
+};
+const checkExist = (first, second, checkedAlias) => {
+  return checkedAlias.some((key) => key === first || key === second);
+};
+const getNormalizedAliases = (aliases) => {
+  const normalizedAliases = cloneDeep(aliases);
+  for (let i = 0; i < normalizedAliases.length; i++) {
+    let alias = normalizedAliases[i];
+    if (alias.length < 1) {
+      normalizedAliases.splice(i, 1);
+      i -= 1;
+      continue;
+    }
+    for (let m = i + 1; m < normalizedAliases.length; m++) {
+      const accumulationAlias = alias;
+      const nextAlias = normalizedAliases[m];
+      if (nextAlias.some((al) => accumulationAlias.includes(al))) {
+        alias = concatUniq(accumulationAlias, nextAlias);
+        normalizedAliases.splice(m, 1);
+        m = i;
+      }
+    }
+    normalizedAliases[i] = alias;
+  }
+  return normalizedAliases;
+};
+const addAlias = (first, second, aliases) => {
+  let isAppended = false;
+  let appended = [];
+  const result = [];
+  for (let i = 0; i < aliases.length; i++) {
+    const alias = aliases[i];
+    if (checkExist(first, second, alias)) {
+      if (isAppended) {
+        const appendedIndex = result.indexOf(appended);
+        appended = concatUniq(alias, appended);
+        result[appendedIndex] = appended;
+      } else {
+        isAppended = true;
+        appended = appendUniq(first, second, alias);
+        result.push(appended);
+      }
+    } else {
+      result.push(alias);
+    }
+  }
+  if (!isAppended) {
+    result.push([first, second]);
+  }
+  return result;
+};
+const hasConnectionsBy = (relation) => {
+  return Boolean(relation?.byUsedParams?.length) || Boolean(relation?.byFields?.length) || Boolean(relation?.byAliases?.length);
+};
+const getUpdatedPreparedRelations = (props) => {
+  const {
+    aliases,
+    currentWidgetId,
+    currentWidgetMeta,
+    changedWidgetsData,
+    dashkitData,
+    dashWidgetsMeta,
+    preparedRelations,
+    datasets,
+    type = "connections"
+  } = props;
+  if (!dashWidgetsMeta || !currentWidgetMeta) {
+    return null;
+  }
+  const connections = getRelationsForSave({
+    changed: changedWidgetsData,
+    dashkitData
+  }) || [];
+  const row = dashWidgetsMeta.find((item) => (item.itemId || item.widgetId) === currentWidgetId);
+  if (!row) {
+    return null;
+  }
+  const newPreparedRelations = [...preparedRelations];
+  const changedRelationsItem = newPreparedRelations.find(
+    (item) => (item.itemId || item.widgetId) === currentWidgetId
+  );
+  const newAliases = Array.isArray(aliases) ? { [DEFAULT_ALIAS_NAMESPACE]: aliases } : aliases;
+  if (type === "aliases") {
+    const relationsItems = [];
+    dashWidgetsMeta.filter((item) => {
+      return (item.itemId || item.widgetId) !== currentWidgetId && showInRelation(currentWidgetMeta, item);
+    }).forEach((item) => {
+      const relations = getRelationsInfo({
+        aliases: newAliases,
+        connections: dashkitData?.props.config.connections || [],
+        datasets,
+        widget: currentWidgetMeta,
+        row: item
+      });
+      relationsItems.push({
+        ...item,
+        relations
+      });
+    });
+    return relationsItems;
+  }
+  if (!changedRelationsItem) {
+    return null;
+  }
+  changedRelationsItem.relations = getRelationsInfo({
+    aliases: newAliases,
+    connections,
+    datasets,
+    widget: currentWidgetMeta,
+    row
+  });
+  return newPreparedRelations;
+};
+const getPairedRelationType = (type) => {
+  switch (type) {
+    case RELATION_TYPES.ignore:
+    case RELATION_TYPES.both:
+      return type;
+    case RELATION_TYPES.input:
+      return RELATION_TYPES.output;
+    case RELATION_TYPES.output:
+      return RELATION_TYPES.input;
+  }
+  return RELATION_TYPES.unknown;
+};
+const getWidgetsOptions = ({
+  widgetsIconMap,
+  widgets,
+  showDebugInfo,
+  tabId
+}) => {
+  const options = [];
+  if (!widgets) {
+    return options;
+  }
+  for (let i = 0; i < widgets?.length; i++) {
+    const widgetItem = widgets[i];
+    switch (widgetItem.type) {
+      case DashTabItemType.GroupControl:
+        {
+          const isVisibleByMainSetting = isGlobalWidgetVisibleByMainSetting(
+            tabId,
+            widgetItem.data.impactType,
+            widgetItem.data.impactTabsIds
+          );
+          widgetItem.data.group.forEach((item) => {
+            const isItemVisible = isGroupItemVisibleOnTab({
+              tabId,
+              item,
+              isVisibleByMainSetting
+            });
+            if (isItemVisible)
+              options.push({
+                value: item.id,
+                content: showDebugInfo ? `(${widgetItem.id} ${item.id}) ${item.title}` : item.title,
+                data: {
+                  widgetId: widgetItem.id,
+                  isItem: true,
+                  icon: widgetsIconMap[widgetItem.id]
+                }
+              });
+          });
+        }
+        break;
+      case DashTabItemType.Widget:
+        widgetItem.data.tabs.forEach((item) => {
+          options.push({
+            value: item.id,
+            content: showDebugInfo ? `(${widgetItem.id} ${item.id}) ${item.title}` : item.title,
+            data: {
+              widgetId: widgetItem.id,
+              icon: widgetsIconMap[item.id]
+            }
+          });
+        });
+        break;
+      case DashTabItemType.Control:
+        {
+          const isVisibleByMainSetting = isGlobalWidgetVisibleByMainSetting(
+            tabId,
+            widgetItem.data.impactType,
+            widgetItem.data.impactTabsIds
+          );
+          if (isVisibleByMainSetting) {
+            options.push({
+              value: widgetItem.id,
+              content: showDebugInfo ? `(${widgetItem.id}) ${widgetItem.data.title}` : widgetItem.data.title,
+              data: { icon: widgetsIconMap[widgetItem.id] }
+            });
+          }
+        }
+        break;
+    }
+  }
+  return options;
+};
+const iconReverse = "data:image/svg+xml,%3csvg%20width='16'%20height='16'%20viewBox='0%200%2016%2016'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M14.398%205.916a.292.292%200%200%200%200-.432L11.86%202.945c-.127-.127-.33-.127-.431%200l-.508.508c-.127.102-.127.305%200%20.432l1.295%201.193H1.805a.309.309%200%200%200-.305.305v.61c0%20.177.127.304.305.304h10.41L10.92%207.516c-.127.127-.127.33%200%20.431l.508.508c.101.127.304.127.431%200l2.54-2.539ZM1.576%2010.791l2.54%202.54c.126.126.33.126.43%200l.509-.509c.127-.101.127-.304%200-.431L3.76%2011.17h10.435a.309.309%200%200%200%20.305-.304v-.61a.328.328%200%200%200-.305-.304H3.76L5.055%208.76c.127-.127.127-.33%200-.432l-.508-.508c-.102-.127-.305-.127-.432%200l-2.539%202.54a.292.292%200%200%200%200%20.431Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const iconRight = "data:image/svg+xml,%3csvg%20width='16'%20height='16'%20viewBox='0%200%2016%2016'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='m9.803%204.57-.508.508a.316.316%200%200%200%20.025.432l2.032%201.955H2.617a.309.309%200%200%200-.304.305v.71c0%20.178.126.305.304.305h8.735l-2.032%201.98a.316.316%200%200%200-.025.432l.508.508a.344.344%200%200%200%20.431%200l3.352-3.351a.344.344%200%200%200%200-.432L10.234%204.57a.344.344%200%200%200-.431%200Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const iconNoData = "data:image/svg+xml,%3csvg%20width='20'%20height='20'%20viewBox='0%200%2020%2020'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20fill-rule='evenodd'%20clip-rule='evenodd'%20d='M3.75%203.75v12.5h12.5V3.75H3.75Zm-.945-.945c.195-.195.46-.305.737-.305h12.916A1.042%201.042%200%200%201%2017.5%203.542v12.916a1.041%201.041%200%200%201-1.042%201.042H3.542A1.041%201.041%200%200%201%202.5%2016.458V3.542c0-.277.11-.542.305-.737Z'%20fill='currentColor'/%3e%3cpath%20fill-rule='evenodd'%20clip-rule='evenodd'%20d='M13.805%2012.669a.667.667%200%201%201-.943.942L10%2010.75l-2.862%202.862a.667.667%200%200%201-.943-.942l2.862-2.862-2.862-2.862a.667.667%200%201%201%20.943-.943L10%208.864l2.862-2.862a.667.667%200%201%201%20.943.943l-2.862%202.862%202.862%202.862Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const iconNoLink = "data:image/svg+xml,%3csvg%20width='16'%20height='16'%20viewBox='0%200%2016%2016'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='m13.56%202.844-.279-.28c-.178-.152-.431-.152-.584%200l-1.726%201.727A4.85%204.85%200%200%200%208%203.25a4.86%204.86%200%200%200-4.875%204.875c0%201.143.38%202.184%201.016%202.996l-1.727%201.727c-.152.152-.152.406%200%20.584l.305.279a.398.398%200%200%200%20.558%200l1.727-1.727A4.848%204.848%200%200%200%208%2013a4.86%204.86%200%200%200%204.875-4.875%204.85%204.85%200%200%200-1.041-2.97l1.726-1.727c.153-.153.153-.407%200-.584ZM4.345%208.125A3.657%203.657%200%200%201%208%204.469c.787%200%201.498.279%202.107.685l-5.103%205.104a3.79%203.79%200%200%201-.66-2.133Zm7.312%200A3.657%203.657%200%200%201%208%2011.781a3.79%203.79%200%200%201-2.133-.66l5.104-5.103c.406.609.685%201.32.685%202.107Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const getTextSeparator = (leftText, rightText) => {
+  return leftText && rightText ? ` — ` : " ";
+};
+const getLinkIcon = (type) => {
+  switch (type) {
+    case "ignore":
+      return iconNoLink;
+    case "input":
+    case "output":
+      return iconRight;
+    case "both":
+      return iconReverse;
+    default:
+      return iconNoData;
+  }
+};
+const getClampedText = (text) => text?.length > TEXT_LIMIT ? `${text.substr(0, TEXT_LIMIT)}...` : text;
+const getRelationsText = (type) => {
+  switch (type) {
+    case "ignore":
+      return "label_ignore";
+    case "input":
+      return "label_input";
+    case "output":
+      return "label_output";
+    case "both":
+      return "label_both";
+    case "unknown":
+      return "label_unknown";
+    default:
+      return "";
+  }
+};
+const getRelationDetailsKey = (item) => {
+  switch (item) {
+    case RELATION_TYPES.input:
+    case RELATION_TYPES.output:
+      return "value_link-affect";
+    case RELATION_TYPES.both:
+      return "value_link-both";
+    case RELATION_TYPES.ignore:
+      return "value_link-ignore";
+    case RELATION_TYPES.unknown:
+    default:
+      return "value_link-unknown";
+  }
+};
+const getRowTitle = (title, label) => {
+  const itemLabel = label && label !== title ? label : "";
+  const separator = getTextSeparator(itemLabel, title);
+  const rowTitle = `${itemLabel}${separator}${title}`.trim();
+  return rowTitle || i18n$9("component.dialog-relations.view", "title-error");
+};
+const iconAlias = "data:image/svg+xml,%3csvg%20width='16'%20height='16'%20viewBox='0%200%2016%2016'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20fill-rule='evenodd'%20clip-rule='evenodd'%20d='M10.625%205.26a1.75%201.75%200%201%201%203.5%200%201.75%201.75%200%200%201-3.5%200Zm1.75-2.75a2.75%202.75%200%200%200-.6%205.435v4.044a.4.4%200%200%201-.4.4h-4a.6.6%200%200%200%200%201.2h4a1.6%201.6%200%200%200%201.6-1.6V7.945a2.751%202.751%200%200%200-.6-5.434ZM4.225%208.055a2.751%202.751%200%201%201-1.2%200V4.01a1.6%201.6%200%200%201%201.6-1.6h4a.6.6%200%200%201%200%201.2h-4a.4.4%200%200%200-.4.4v4.044Zm1.15%202.684a1.75%201.75%200%201%201-3.5%200%201.75%201.75%200%200%201%203.5%200Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const b$7 = block("dialog-relations-content");
+const i18n$7 = I18n.keyset("component.dialog-relations.view");
+const ICON_SIZE$1 = 16;
+const getRelationDetailsText = ({
+  text,
+  linkType,
+  widget,
+  row,
+  withStrong
+}) => {
+  const widgetNameTextWrapped = withStrong ? /* @__PURE__ */ jsx("strong", { children: widget }) : widget;
+  const rowNameTextWrapped = withStrong ? /* @__PURE__ */ jsx("strong", { children: row }) : row;
+  if (linkType === RELATION_TYPES.output) {
+    if (!rowNameTextWrapped) {
+      return "";
+    }
+    return withStrong ? /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      widgetNameTextWrapped,
+      " ",
+      text,
+      " ",
+      rowNameTextWrapped
+    ] }) : `${widgetNameTextWrapped} ${text} ${rowNameTextWrapped}`;
+  }
+  if (linkType === RELATION_TYPES.input) {
+    if (!widgetNameTextWrapped) {
+      return "";
+    }
+    return withStrong ? /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      rowNameTextWrapped,
+      " ",
+      text,
+      " ",
+      widgetNameTextWrapped
+    ] }) : `${rowNameTextWrapped} ${text} ${widgetNameTextWrapped}`;
+  }
+  return text;
+};
+const labelsMap = {
+  field: {
+    singleLabel: i18n$7("label_by-field"),
+    multiLabel: i18n$7("label_by-fields")
+  },
+  alias: {
+    singleLabel: i18n$7("label_by-alias"),
+    multiLabel: i18n$7("label_by-aliases")
+  },
+  param: {
+    singleLabel: i18n$7("label_by-parameter"),
+    multiLabel: i18n$7("label_by-parameters")
+  }
+};
+const getFieldText = ({
+  field,
+  type,
+  hasDataset
+}) => {
+  let fieldText = "";
+  let fieldTextWithStrong = null;
+  if (type === "indirect") {
+    return {
+      fieldText,
+      fieldTextWithStrong
+    };
+  }
+  const byField = type === "field" || type === "param";
+  const { singleLabel, multiLabel } = labelsMap[type];
+  if (Array.isArray(field) && field.length) {
+    const fieldLabel = field.length === 1 ? singleLabel : multiLabel;
+    const fieldName = byField ? Array.isArray(field) && field?.join(", ") || "" : "";
+    fieldText = ` ${fieldLabel} ${fieldName}`;
+    const fieldNameWithStrong = byField ? /* @__PURE__ */ jsx("strong", { children: fieldName }) : null;
+    fieldTextWithStrong = /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      " ",
+      fieldLabel,
+      " ",
+      fieldNameWithStrong
+    ] });
+  } else if (type === "field" && hasDataset && !field.length) {
+    fieldText = ` ${i18n$7("label_by-dataset-fields")}`;
+    fieldTextWithStrong = /* @__PURE__ */ jsx(React__default.Fragment, { children: fieldText });
+  }
+  return {
+    fieldText,
+    fieldTextWithStrong
+  };
+};
+const getConnectionByInfo = ({
+  byFields,
+  byUsedParams,
+  byAliases,
+  relationType,
+  indirectAliases,
+  hasDataset
+}) => {
+  const isUnknownRelation = relationType === RELATION_TYPES.unknown;
+  const availableLink = relationType !== RELATION_TYPES.ignore && relationType !== RELATION_TYPES.unknown;
+  const hasIndirectAliases = Boolean(indirectAliases.length);
+  const hasUsedParams = Array.isArray(byUsedParams) ? Boolean(byUsedParams.length) : Boolean(byUsedParams);
+  const showByUsedParams = hasUsedParams && availableLink;
+  const hasFields = Array.isArray(byFields) ? Boolean(byFields.length) : Boolean(byFields);
+  const showByField = hasFields && availableLink;
+  const hasAliases = Array.isArray(byAliases) ? Boolean(byAliases.length) : Boolean(byAliases);
+  const showByAlias = hasAliases && availableLink;
+  let field;
+  let type;
+  switch (true) {
+    case showByAlias: {
+      field = byAliases;
+      type = "alias";
+      break;
+    }
+    case (showByField || hasDataset && availableLink): {
+      field = byFields;
+      type = "field";
+      break;
+    }
+    case showByUsedParams: {
+      field = byUsedParams;
+      type = "param";
+      break;
+    }
+    case (isUnknownRelation && hasIndirectAliases): {
+      field = indirectAliases;
+      type = "indirect";
+      break;
+    }
+    default: {
+      field = [];
+      type = "field";
+    }
+  }
+  const { fieldText, fieldTextWithStrong } = getFieldText({
+    field,
+    type,
+    hasDataset
+  });
+  return {
+    showByField: showByField || hasDataset || showByAlias || showByUsedParams,
+    fieldText,
+    fieldTextWithStrong
+  };
+};
+const getTooltipInfo = ({
+  widget,
+  row,
+  relationType,
+  byFields,
+  byAliases,
+  byUsedParams,
+  indirectAliases,
+  hasDataset
+}) => {
+  const { fieldText, fieldTextWithStrong, showByField } = getConnectionByInfo({
+    byFields,
+    byAliases,
+    relationType,
+    byUsedParams,
+    indirectAliases,
+    hasDataset
+  });
+  const widgetLabel = widget?.label && widget?.title !== widget?.label ? `${widget?.label}` : "";
+  const rowLabel = row?.label && row?.title !== row?.label ? `${row?.label}` : "";
+  const tooltipWidgetTitle = getClampedText(widget.title);
+  const tooltipRowTitle = getClampedText(row.title);
+  const tooltipWidgetSeparator = getTextSeparator(widgetLabel, tooltipWidgetTitle);
+  const tooltipRowSeparator = getTextSeparator(rowLabel, tooltipRowTitle);
+  const tooltipContent = /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    getRelationDetailsText({
+      text: i18n$7(getRelationDetailsKey(relationType)),
+      linkType: relationType,
+      widget: `${widgetLabel}${tooltipWidgetSeparator}${tooltipWidgetTitle}`,
+      row: `${rowLabel}${tooltipRowSeparator}${tooltipRowTitle}`,
+      withStrong: true
+    }),
+    showByField && fieldTextWithStrong
+  ] });
+  const widgetTitle = widget.title;
+  const rowTitle = row.title;
+  const widgetSeparator = getTextSeparator(widgetLabel, widgetTitle);
+  const rowSeparator = getTextSeparator(rowLabel, rowTitle);
+  const tooltipTitle = widget.title?.length > TEXT_LIMIT || rowTitle?.length > TEXT_LIMIT ? getRelationDetailsText({
+    text: i18n$7(getRelationDetailsKey(relationType)),
+    linkType: relationType,
+    widget: `${widgetLabel}${widgetSeparator}${widgetTitle}`,
+    row: `${rowLabel}${rowSeparator}${rowTitle}`
+  }) + (showByField ? fieldText : "") : void 0;
+  const aliasDetailTitle = /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    getRelationDetailsText({
+      text: i18n$7(getRelationDetailsKey(relationType)),
+      linkType: relationType,
+      widget: `${widgetLabel}${widgetSeparator}${widgetTitle}`,
+      row: `${rowLabel}${rowSeparator}${rowTitle}`,
+      withStrong: true
+    }),
+    showByField ? fieldText : ""
+  ] });
+  return {
+    tooltipContent,
+    tooltipTitle,
+    aliasDetailTitle
+  };
+};
+const getDropdownItems = ({
+  items,
+  currentWidget,
+  currentRow,
+  onChange
+}) => items.map((item) => ({
+  action: () => {
+    onChange({ type: item, widgetId: currentRow.widgetId, itemId: currentRow.itemId });
+  },
+  iconStart: /* @__PURE__ */ jsx(Icon, { data: getLinkIcon(item), size: ICON_SIZE$1, className: b$7("icon-link", item) }),
+  text: /* @__PURE__ */ jsxs("div", { className: b$7("list-link"), "data-qa": DashRelationTypes[item], children: [
+    /* @__PURE__ */ jsx("span", { children: i18n$7(`label_${item}`) }),
+    /* @__PURE__ */ jsx("div", { className: b$7("info-text"), children: getRelationDetailsText({
+      text: i18n$7(getRelationDetailsKey(item)),
+      linkType: item,
+      widget: getClampedText(currentWidget),
+      row: getClampedText(currentRow.title || currentRow.label || "")
+    }) })
+  ] }),
+  className: b$7("list-row")
+}));
+const Row = ({
+  data,
+  widgetMeta,
+  onChange,
+  onAliasClick,
+  showDebugInfo,
+  widgetIcon
+}) => {
+  const relations = data?.relations;
+  const {
+    type: relationType,
+    available: availableRelations,
+    indirectAliases,
+    byFields,
+    byAliases,
+    byUsedParams,
+    hasDataset,
+    forceAddAlias
+  } = relations;
+  const { tooltipContent, tooltipTitle, aliasDetailTitle } = getTooltipInfo({
+    widget: widgetMeta,
+    row: data,
+    relationType,
+    byFields,
+    byAliases,
+    byUsedParams,
+    indirectAliases,
+    hasDataset
+  });
+  const icon = getRelationsIcon(data);
+  const handleAliasCLick = React__default.useCallback(() => {
+    onAliasClick?.({
+      currentRow: data,
+      showDebugInfo,
+      relationText: aliasDetailTitle || "",
+      relationType,
+      widgetIcon,
+      rowIcon: icon
+    });
+  }, [data, showDebugInfo, onAliasClick, relationType, aliasDetailTitle, widgetIcon, icon]);
+  const handleChange = React__default.useCallback(
+    (changedData) => {
+      onChange({
+        ...changedData,
+        currentRow: data,
+        showDebugInfo,
+        relationText: aliasDetailTitle || "",
+        relationType,
+        widgetIcon,
+        rowIcon: icon,
+        forceAddAlias
+      });
+    },
+    [
+      aliasDetailTitle,
+      data,
+      icon,
+      onChange,
+      relationType,
+      showDebugInfo,
+      widgetIcon,
+      forceAddAlias
+    ]
+  );
+  if (!data || !widgetMeta) {
+    return null;
+  }
+  const relationTypeText = i18n$7(getRelationsText(relationType));
+  const items = getDropdownItems({
+    items: availableRelations,
+    currentWidget: widgetMeta.title || widgetMeta.label || "",
+    currentRow: data,
+    onChange: handleChange
+  });
+  const showAliasIcon = Boolean(data.loaded);
+  const id = data.itemId ? `${data.widgetId} ${data.itemId}` : data.widgetId;
+  const debugInfo = showDebugInfo ? /* @__PURE__ */ jsxs("span", { className: b$7("info"), children: [
+    " (",
+    id,
+    ")"
+  ] }) : null;
+  const rowTitle = getRowTitle(data.title, data.label);
+  const title = (showDebugInfo ? `(${id}) ` : "") + rowTitle;
+  return /* @__PURE__ */ jsxs("div", { className: b$7("row"), "data-qa": DashCommonQa.RelationsListRow, children: [
+    /* @__PURE__ */ jsx("div", { className: b$7("left"), children: /* @__PURE__ */ jsxs("div", { className: b$7("left-inner"), children: [
+      /* @__PURE__ */ jsx("div", { className: b$7("icon"), children: icon }),
+      /* @__PURE__ */ jsxs("span", { className: b$7("text"), title, children: [
+        debugInfo,
+        rowTitle
+      ] }),
+      showAliasIcon && /* @__PURE__ */ jsx(
+        Button,
+        {
+          view: "outlined",
+          size: "s",
+          title: i18n$7("label_add-alias"),
+          className: b$7("button-alias"),
+          onClick: handleAliasCLick,
+          qa: DashCommonQa.AliasShowBtn,
+          children: /* @__PURE__ */ jsx(Icon, { data: iconAlias, className: b$7("icon-alias") })
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx("div", { className: b$7("right"), children: relationType && /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        DropdownMenu,
+        {
+          size: "l",
+          items,
+          renderSwitcher: ({ onClick, onKeyDown }) => /* @__PURE__ */ jsxs(
+            Button,
+            {
+              view: "flat",
+              className: b$7("button-link"),
+              qa: DashCommonQa.RelationTypeButton,
+              onClick,
+              onKeyDown,
+              children: [
+                /* @__PURE__ */ jsx("span", { className: b$7("button-link-icon-wrap"), children: /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    data: getLinkIcon(relationType),
+                    size: ICON_SIZE$1,
+                    className: b$7("icon-link", relationType)
+                  }
+                ) }),
+                relationTypeText
+              ]
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Popover,
+        {
+          content: /* @__PURE__ */ jsx("div", { className: b$7("popover-content"), title: tooltipTitle, children: tooltipContent }),
+          placement: "bottom",
+          hasArrow: false,
+          children: /* @__PURE__ */ jsx(
+            Icon,
+            {
+              qa: DashCommonQa.RelationsRowPopover,
+              data: iconInfo,
+              size: ICON_SIZE$1,
+              className: b$7("icon-info")
+            }
+          )
+        }
+      )
+    ] }) })
+  ] });
+};
+const b$6 = block("dialog-relations-content");
+const i18n$6 = I18n.keyset("component.dialog-relations.view");
+const Content = ({
+  relations,
+  widgetMeta,
+  isLoading,
+  onChange,
+  onAliasClick,
+  showDebugInfo,
+  widgetIcon
+}) => {
+  if (isLoading) {
+    return /* @__PURE__ */ jsx("div", { className: b$6({ "with-loader": true }), children: /* @__PURE__ */ jsx("div", { className: b$6("loader-wrap"), children: /* @__PURE__ */ jsx(Loader, { className: b$6("loader") }) }) });
+  }
+  if (!relations.length) {
+    return /* @__PURE__ */ jsx("div", { className: b$6("empty-text"), "data-qa": DashCommonQa.RelationsDialogEmptyText, children: i18n$6("label_no-connections") });
+  }
+  if (!widgetMeta) {
+    return /* @__PURE__ */ jsx("div", { className: b$6("empty-text"), children: i18n$6("label_no-widget-info") });
+  }
+  const content = relations.map((item, index) => /* @__PURE__ */ jsx(
+    Row,
+    {
+      data: item,
+      widgetMeta,
+      onChange,
+      onAliasClick,
+      showDebugInfo,
+      widgetIcon
+    },
+    `relations-row-${item.widgetId}-${index}`
+  ));
+  return /* @__PURE__ */ jsx("div", { className: b$6(), children: Boolean(relations.length) && /* @__PURE__ */ jsxs("div", { className: b$6("items"), children: [
+    /* @__PURE__ */ jsxs("div", { className: b$6("row", "top"), children: [
+      /* @__PURE__ */ jsx("div", { className: b$6("left", "top"), children: i18n$6("label_widget") }),
+      /* @__PURE__ */ jsx("div", { className: b$6("right", "top"), children: i18n$6("label_relation-type") })
+    ] }),
+    content
+  ] }) });
+};
+const AliasesContext = React__default.createContext({});
+const useRelations = ({
+  dashKitRef,
+  widget,
+  dialogAliases,
+  workbookId,
+  itemId,
+  widgetsCurrentTab
+}) => {
+  const [isInited, setIsInited] = React__default.useState(false);
+  const [isLoading, setIsLoading] = React__default.useState(false);
+  const [relations, setRelations] = React__default.useState([]);
+  const [currentWidgetMeta, setCurrentWidgetMeta] = React__default.useState(
+    null
+  );
+  const [invalidAliases, setInvalidAliases] = React__default.useState([]);
+  const [dashWidgetsMeta, setDashWidgetsMeta] = React__default.useState(null);
+  const [datasets, setDatasets] = React__default.useState(null);
+  const [prevItemId, setPrevItemId] = React__default.useState(itemId);
+  const [prevWidgetId, setPrevWidgetId] = React__default.useState(widget?.id ?? null);
+  const getCurrentWidgetInfo = React__default.useCallback(
+    (dashWidgetsMetaData, datasetsList) => {
+      if (!dashKitRef?.current || !widget) {
+        return;
+      }
+      const { connections } = dashKitRef.current.props.config;
+      const widgetCurrentTabId = widgetsCurrentTab[widget.id];
+      const currentMeta = getCurrentWidgetMeta({
+        metaData: dashWidgetsMetaData,
+        dashkitData: dashKitRef.current,
+        widget,
+        itemId,
+        tabId: widgetCurrentTabId
+      });
+      const currentRelations = getRelationsData({
+        metaData: dashWidgetsMetaData,
+        widgetMeta: currentMeta,
+        aliases: dialogAliases,
+        connections,
+        datasets: datasetsList
+      });
+      setCurrentWidgetMeta(currentMeta);
+      setRelations(currentRelations);
+    },
+    [dashKitRef, dialogAliases, itemId, widget, widgetsCurrentTab]
+  );
+  if (isInited && (itemId !== prevItemId || widget?.id !== prevWidgetId) && dashWidgetsMeta && datasets) {
+    getCurrentWidgetInfo(dashWidgetsMeta, datasets);
+    setPrevWidgetId(widget?.id ?? null);
+    setPrevItemId(itemId);
+  }
+  React__default.useEffect(() => {
+    const getMetaData = async () => {
+      if (!dashKitRef?.current || !widget) {
+        return;
+      }
+      setIsLoading(true);
+      const data = await Promise.all(dashKitRef.current.getItemsMeta());
+      const { metaData, datasetsList, entriesList, controlsList } = getPreparedMetaData(
+        data,
+        dashKitRef.current
+      );
+      let entriesDatasetsFields = [];
+      if (!isEmpty(entriesList) && (!isEmpty(datasetsList) || !isEmpty(controlsList))) {
+        entriesDatasetsFields = await getSdk().sdk.mix.getEntriesDatasetsFields({
+          entriesIds: entriesList,
+          datasetsIds: Object.keys(datasetsList),
+          workbookId
+        });
+      }
+      const dashWidgetsMetaData = entriesDatasetsFields.length ? getMetaDataWithDatasetInfo({
+        metaData,
+        entriesDatasetsFields,
+        datasetsList
+      }) : metaData;
+      dashWidgetsMetaData.sort((prevItem, item) => {
+        const prevItemTitle = getRowTitle(prevItem.title, prevItem.label);
+        const itemTitle = getRowTitle(item.title, item.label);
+        return prevItemTitle.localeCompare(itemTitle);
+      });
+      const fetchedDatasets = entriesDatasetsFields?.filter((item) => item.type === "dataset") || [];
+      if (fetchedDatasets?.length) {
+        fetchedDatasets.forEach((datasetItem) => {
+          if (datasetItem.datasetId && datasetItem.datasetId in datasetsList) {
+            const datasetListItem = datasetsList[datasetItem.datasetId];
+            if (!datasetListItem.name && datasetItem.datasetName) {
+              datasetListItem.name = datasetItem.datasetName;
+            }
+            if (!datasetListItem.fields && datasetItem.datasetFields) {
+              datasetListItem.fields = datasetItem.datasetFields;
+            }
+          }
+        });
+      }
+      const allUsedParams = dashWidgetsMetaData.reduce((result, item) => {
+        (item.usedParams || []).forEach(result.add, result);
+        Object.keys(item.widgetParams || {}).forEach(result.add, result);
+        return result;
+      }, /* @__PURE__ */ new Set());
+      const invalidAliasesData = [];
+      if (DEFAULT_ALIAS_NAMESPACE in dialogAliases) {
+        dialogAliases[DEFAULT_ALIAS_NAMESPACE].forEach((aliasRow) => {
+          aliasRow.forEach((item) => {
+            if (!allUsedParams.has(item)) {
+              invalidAliasesData.push(item);
+            }
+          });
+        });
+      }
+      getCurrentWidgetInfo(dashWidgetsMetaData, datasetsList);
+      setIsInited(true);
+      setIsLoading(false);
+      setDatasets(datasetsList);
+      setDashWidgetsMeta(dashWidgetsMetaData);
+      setInvalidAliases(invalidAliasesData);
+    };
+    if (!isInited) {
+      if (!dashKitRef?.current) {
+        return;
+      }
+      getMetaData();
+    }
+  }, [
+    dashKitRef,
+    isInited,
+    widget,
+    dialogAliases,
+    workbookId,
+    itemId,
+    datasets,
+    dashWidgetsMeta,
+    prevItemId,
+    getCurrentWidgetInfo
+  ]);
+  return { isLoading, relations, currentWidgetMeta, datasets, dashWidgetsMeta, invalidAliases };
+};
+const b$5 = block("dialog-aliases-list");
+const i18n$5 = I18n.keyset("component.dialog-relations.view");
+const getFieldNameByGuid = (datasets, aliasItem) => {
+  let dataset = null;
+  for (const [key, value] of Object.entries(datasets || {})) {
+    const field = value?.fields.find((fieldItem) => fieldItem.guid === aliasItem) || null;
+    if (field) {
+      dataset = {
+        datasetId: key,
+        field,
+        datasetName: value.name || ""
+      };
+      return dataset;
+    }
+  }
+  return {
+    datasetId: null,
+    datasetName: null,
+    field: null
+  };
+};
+const AliasesListItem = ({
+  row,
+  widgetId,
+  onDetailClick,
+  onRemoveClick,
+  onSelectParam,
+  indexRow
+}) => {
+  const { datasets, selectedAliasRowIndex, selectedParam, invalidAliases } = React__default.useContext(AliasesContext);
+  const handleRemoveAliasRow = React__default.useCallback(() => {
+    onRemoveClick({
+      row
+    });
+  }, [onRemoveClick, row]);
+  const isRowActive = selectedAliasRowIndex === indexRow;
+  const handleRemoveAliasItemFromRow = React__default.useCallback(
+    (index) => {
+      const rowWithPartlyRemoved = [];
+      row.forEach((item, itemRowIndex) => {
+        if (index !== itemRowIndex) {
+          rowWithPartlyRemoved.push(item);
+        }
+      });
+      onRemoveClick({
+        row,
+        rowWithPartlyRemoved
+      });
+    },
+    [onRemoveClick, row]
+  );
+  return /* @__PURE__ */ jsxs("div", { className: b$5("row", { active: isRowActive }), children: [
+    /* @__PURE__ */ jsx("div", { className: b$5("left"), children: row.map((aliasItem, index, array) => {
+      const { datasetId, field, datasetName } = getFieldNameByGuid(datasets, aliasItem);
+      const datasetText = datasetId ? ` (${i18n$5("label_dataset")}: ${datasetName ? datasetName : datasetId})` : "";
+      const fieldName = field?.title || aliasItem;
+      const isAliasItemSelected = selectedParam === aliasItem && isRowActive;
+      const isInvalidItem = invalidAliases?.includes(aliasItem);
+      let buttonView = "outlined";
+      if (isInvalidItem) {
+        buttonView = "outlined-danger";
+      } else if (isAliasItemSelected) {
+        buttonView = "outlined-info";
+      }
+      const showRemoveItemIcon = isAliasItemSelected && array.length > 2;
+      return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            className: b$5("alias-button"),
+            view: buttonView,
+            size: "m",
+            onClick: () => onSelectParam({
+              index,
+              indexRow,
+              aliasRow: row,
+              fieldName: `${fieldName}${datasetText}`,
+              field
+            }),
+            qa: DashCommonQa.AliasItem,
+            children: [
+              /* @__PURE__ */ jsxs(
+                "span",
+                {
+                  className: b$5("button-text", {
+                    "with-remove": showRemoveItemIcon
+                  }),
+                  children: [
+                    fieldName,
+                    datasetId && /* @__PURE__ */ jsx("span", { className: b$5("info"), children: datasetText })
+                  ]
+                }
+              ),
+              showRemoveItemIcon && /* @__PURE__ */ jsx(
+                "span",
+                {
+                  onClick: () => handleRemoveAliasItemFromRow(index),
+                  className: b$5("remove-item"),
+                  children: /* @__PURE__ */ jsx(Icon, { data: Xmark })
+                }
+              )
+            ]
+          }
+        ),
+        index !== array.length - 1 && /* @__PURE__ */ jsx("span", { className: b$5("separator"), children: "=" })
+      ] }, `alias-row-${widgetId}-${aliasItem}`);
+    }) }),
+    /* @__PURE__ */ jsxs("div", { className: b$5("right"), children: [
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: b$5("alias-icon-button", { active: isRowActive }),
+          view: "flat",
+          onClick: () => onDetailClick({
+            indexRow,
+            aliasRow: row
+          }),
+          title: i18n$5("button_show-related-widgets"),
+          children: /* @__PURE__ */ jsx(Icon, { data: Magnifier })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: b$5("alias-icon-button", { active: isRowActive }, "remove"),
+          view: "flat",
+          onClick: handleRemoveAliasRow,
+          title: i18n$5("button_delete-alias"),
+          qa: DashCommonQa.AliasRemoveBtn,
+          children: /* @__PURE__ */ jsx(Icon, { data: TrashBin })
+        }
+      )
+    ] })
+  ] });
+};
+const AliasesList = (props) => {
+  const { onAliasRowClick, showDetailedData } = props;
+  const [selectedAliasParamIndex, setSelectedAliasParamIndex] = React__default.useState(
+    null
+  );
+  const { selectedAliasRowIndex } = React__default.useContext(AliasesContext);
+  const handleSelectParam = React__default.useCallback(
+    (args) => {
+      const isClickedOnSelected = showDetailedData && args.index === selectedAliasParamIndex && args.indexRow === selectedAliasRowIndex;
+      const paramIndex = isClickedOnSelected ? null : args.index;
+      setSelectedAliasParamIndex(paramIndex);
+      onAliasRowClick({ ...args, isClickedOnSelected });
+    },
+    [showDetailedData, selectedAliasParamIndex, selectedAliasRowIndex, onAliasRowClick]
+  );
+  React__default.useEffect(() => {
+    setSelectedAliasParamIndex(selectedAliasRowIndex);
+  }, [selectedAliasRowIndex]);
+  return /* @__PURE__ */ jsx(React__default.Fragment, { children: props.aliases.map((row, indexRow) => /* @__PURE__ */ jsx(
+    AliasesListItem,
+    {
+      ...props,
+      row,
+      indexRow,
+      onSelectParam: handleSelectParam
+    },
+    `alias-${props.widgetId}-${indexRow}-${row.join("-")}`
+  )) });
+};
+const b$4 = block("dialog-aliases-list");
+const i18n$4 = I18n.keyset("component.dialog-relations.view");
+const AliasesInvalidListItem = (props) => {
+  const { row, invalidAliases, datasets } = props;
+  return /* @__PURE__ */ jsx("div", { className: b$4("row"), children: /* @__PURE__ */ jsx("div", { className: b$4("left"), children: row.map((aliasItem, index, array) => {
+    const { datasetId, field, datasetName } = getFieldNameByGuid(datasets, aliasItem);
+    const datasetText = datasetId ? ` (${i18n$4("label_dataset")}: ${datasetName ? datasetName : datasetId})` : "";
+    const fieldName = field?.title || aliasItem;
+    const isInvalidItem = invalidAliases?.includes(aliasItem);
+    const buttonView = isInvalidItem ? "outlined-danger" : "outlined";
+    return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          className: b$4("alias-button", "not-active"),
+          view: buttonView,
+          size: "m",
+          children: [
+            fieldName,
+            datasetId && /* @__PURE__ */ jsx("span", { className: b$4("info"), children: datasetText })
+          ]
+        }
+      ),
+      index !== array.length - 1 && /* @__PURE__ */ jsx("span", { className: b$4("separator"), children: "=" })
+    ] }, `alias-row-invalid-${aliasItem}`);
+  }) }) });
+};
+const AliasesInvalidList = (props) => {
+  const { aliases, invalidAliases, onClose, onClear } = props;
+  const aliasesWithInvalidList = aliases.filter((itemsRow) => {
+    return Boolean(itemsRow.filter((item) => invalidAliases?.includes(item)).length);
+  });
+  const showControls = Boolean(onClose) && Boolean(onClear);
+  const handleOnClear = React__default.useCallback(() => {
+    if (onClose && onClear) {
+      onClear();
+      onClose();
+    }
+  }, [onClear, onClose]);
+  return /* @__PURE__ */ jsxs("div", { className: b$4("invalid-list"), children: [
+    /* @__PURE__ */ jsx("div", { className: b$4("invalid-list-items"), children: aliasesWithInvalidList.map((row, indexRow) => /* @__PURE__ */ jsx(
+      AliasesInvalidListItem,
+      {
+        ...props,
+        row,
+        invalidAliases
+      },
+      `alias-invalid-${indexRow}-${row.join("-")}`
+    )) }),
+    showControls ? /* @__PURE__ */ jsxs("div", { className: b$4("controls"), children: [
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: b$4("alias-clear-button"),
+          view: "flat",
+          onClick: onClose,
+          title: i18n$4("button_cancel"),
+          children: i18n$4("button_cancel")
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: b$4("alias-clear-button"),
+          view: "outlined",
+          onClick: handleOnClear,
+          title: i18n$4("button_clear-alias"),
+          children: i18n$4("button_clear-alias")
+        }
+      )
+    ] }) : null
+  ] });
+};
+const compareSearchValueGetter = (searchValue) => {
+  const trimmedSearchValue = searchValue.trim();
+  if (trimmedSearchValue) {
+    return (title) => title.toLocaleLowerCase().includes(searchValue.toLowerCase());
+  }
+  return () => true;
+};
+const useFilteredRelations = ({
+  relations,
+  searchValue,
+  typeValues,
+  changedWidgets,
+  currentWidgetId
+}) => {
+  const [filteredRelations, setFilteredRelations] = React__default.useState([]);
+  const showedRelations = React__default.useMemo(
+    () => changedWidgets ? getChangedRelations(relations, changedWidgets, currentWidgetId) : relations,
+    [relations, changedWidgets, currentWidgetId]
+  );
+  React__default.useEffect(() => {
+    if (!showedRelations?.length) {
+      setFilteredRelations([]);
+      return;
+    }
+    const mappedFilters = getMappedFilters(typeValues);
+    const compareTitle = compareSearchValueGetter(searchValue);
+    const filteredItems = showedRelations.filter((item) => {
+      const hasSearch = compareTitle(getRowTitle(item.title, item.label));
+      const hasFilteredType = mappedFilters[item.relations.type];
+      return hasSearch && hasFilteredType;
+    });
+    setFilteredRelations(filteredItems);
+  }, [showedRelations, typeValues, searchValue]);
+  return { filteredRelations };
+};
+const b$3 = block("dialog-relations");
+const i18n$3 = I18n.keyset("component.dialog-relations.view");
+const ICON_SIZE = 16;
+const DIALOG_RELATIONS = /* @__PURE__ */ Symbol("dash/DIALOG_RELATIONS");
+const renderOptions = (option) => /* @__PURE__ */ jsx(SelectOptionWithIcon, { option });
+const EmptyState = () => {
+  return /* @__PURE__ */ jsx(
+    PlaceholderIllustration,
+    {
+      className: b$3("empty-state"),
+      size: "m",
+      direction: "column",
+      name: "emptyDirectory",
+      title: i18n$3("title_empty-selected-widgets")
+    }
+  );
+};
+const DialogRelations = (props) => {
+  const [currentWidget, setCurrentWidget] = React__default.useState(
+    props.widget ?? null
+  );
+  const {
+    dashKitRef,
+    dashTabAliases,
+    workbookId,
+    widgetsCurrentTab,
+    allWidgets: widgets,
+    onClose,
+    onApply
+  } = props;
+  const dispatch = useDispatch();
+  const showDebugInfo = useSelector(selectDebugMode);
+  const tabId = useSelector(selectCurrentTabId);
+  const aliasWarnButtonRef = React__default.useRef(null);
+  const [aliasWarnPopupOpen, setAliasWarnPopupOpen] = React__default.useState(false);
+  const [searchValue, setSearchValue] = React__default.useState("");
+  const [typeValues, setTypeValues] = React__default.useState([]);
+  const [preparedRelations, setPreparedRelations] = React__default.useState([]);
+  const [aliases, setAliases] = React__default.useState(dashTabAliases || {});
+  const [itemId, setItemId] = React__default.useState(
+    currentWidget?.type === DashTabItemType.GroupControl ? currentWidget.data.group[0].id : null
+  );
+  const { isLoading, currentWidgetMeta, relations, datasets, dashWidgetsMeta, invalidAliases } = useRelations({
+    dashKitRef,
+    widget: currentWidget,
+    dialogAliases: aliases,
+    workbookId,
+    itemId,
+    widgetsCurrentTab
+  });
+  const widgetsIconMap = React__default.useMemo(() => {
+    const iconsMap = {};
+    dashWidgetsMeta?.forEach((widgetMeta) => {
+      iconsMap[widgetMeta.widgetId] = getRelationsIcon(widgetMeta, b$3("relations-icon"));
+    });
+    return iconsMap;
+  }, [dashWidgetsMeta]);
+  const widgetOptions = React__default.useMemo(() => {
+    return getWidgetsOptions({ tabId, widgetsIconMap, widgets, showDebugInfo });
+  }, [tabId, widgetsIconMap, widgets, showDebugInfo]);
+  const currentWidgetId = itemId || currentWidgetMeta?.widgetId || "";
+  const [changedWidgets, setChangedWidgets] = React__default.useState({});
+  const [shownInvalidAliases, setShownInvalidAliases] = React__default.useState(null);
+  const { filteredRelations } = useFilteredRelations({
+    relations: preparedRelations,
+    searchValue,
+    typeValues,
+    changedWidgets,
+    currentWidgetId
+  });
+  const handleItemChange = (value) => {
+    const newWidgetData = widgetOptions.find((item) => item.value === value[0])?.data;
+    const currentId = newWidgetData?.widgetId || value[0];
+    const newCurrentWidget = widgets?.find((item) => item.id === currentId);
+    setCurrentWidget(newCurrentWidget);
+    setItemId(newWidgetData?.isItem ? value[0] : null);
+    setPreparedRelations([]);
+    if (!changedWidgets[currentId]) {
+      const updatedChangedWidgets = { ...changedWidgets };
+      updatedChangedWidgets[currentId] = {};
+      setChangedWidgets(updatedChangedWidgets);
+    }
+  };
+  const handleFilterInputChange = React__default.useCallback((data) => {
+    setSearchValue(data);
+  }, []);
+  const handleFilterTypesChange = React__default.useCallback((data) => {
+    setTypeValues(data);
+  }, []);
+  const handleUpdateRelations = React__default.useCallback(
+    (changedAliases) => {
+      if (isEmpty(preparedRelations)) {
+        return;
+      }
+      const relationsWithChangedAliases = preparedRelations.map((widgetItem) => {
+        const byAliases = changedAliases.filter((aliasArr) => {
+          if (!widgetItem.usedParams?.length) {
+            return false;
+          }
+          return intersection(widgetItem.usedParams, aliasArr);
+        });
+        return {
+          ...widgetItem,
+          relations: {
+            ...widgetItem.relations,
+            byAliases
+          }
+        };
+      });
+      if (DEFAULT_ALIAS_NAMESPACE in aliases) {
+        const newAliases = Object.assign({
+          ...aliases,
+          [DEFAULT_ALIAS_NAMESPACE]: changedAliases
+        });
+        setAliases(newAliases);
+      }
+      setPreparedRelations(relationsWithChangedAliases);
+    },
+    [aliases, preparedRelations]
+  );
+  const handleUpdateAliases = React__default.useCallback(
+    (newNamespacedAliases) => {
+      const newAliases = {
+        ...aliases,
+        [DEFAULT_ALIAS_NAMESPACE]: newNamespacedAliases
+      };
+      setAliases(newAliases);
+      handleUpdateRelations(newNamespacedAliases);
+      const newPreparedRelations = getUpdatedPreparedRelations({
+        aliases: newAliases,
+        currentWidgetMeta,
+        changedWidgetsData: changedWidgets,
+        dashkitData: dashKitRef.current || null,
+        dashWidgetsMeta,
+        preparedRelations,
+        datasets,
+        currentWidgetId,
+        type: "aliases"
+      });
+      if (!newPreparedRelations) {
+        return;
+      }
+      const newChangedWidgets = { ...changedWidgets };
+      newPreparedRelations.forEach((item) => {
+        if (changedWidgets && changedWidgets[currentWidgetId] && item.widgetId in changedWidgets[currentWidgetId] && item.relations.type !== changedWidgets[currentWidgetId][item.widgetId]) {
+          delete newChangedWidgets[item.widgetId];
+        }
+      });
+      setChangedWidgets(newChangedWidgets);
+      setPreparedRelations(newPreparedRelations);
+    },
+    [
+      aliases,
+      handleUpdateRelations,
+      currentWidgetMeta,
+      changedWidgets,
+      dashKitRef,
+      dashWidgetsMeta,
+      preparedRelations,
+      datasets,
+      currentWidgetId
+    ]
+  );
+  const handleAliasesClosed = React__default.useCallback((args) => {
+    if (args?.reset || !args?.changedWidgetsData) {
+      return;
+    }
+    setChangedWidgets(args.changedWidgetsData);
+  }, []);
+  const handleAliasesClick = React__default.useCallback(
+    (data) => {
+      dispatch(
+        openDialogAliases({
+          relations: filteredRelations,
+          currentWidget: currentWidgetMeta,
+          datasets,
+          updateRelations: handleUpdateRelations,
+          updateAliases: handleUpdateAliases,
+          onCloseCallback: handleAliasesClosed,
+          forceAddAlias: false,
+          invalidAliases: shownInvalidAliases,
+          ...data,
+          dialogAliases: aliases
+        })
+      );
+    },
+    [
+      dispatch,
+      handleUpdateAliases,
+      handleUpdateRelations,
+      datasets,
+      filteredRelations,
+      currentWidgetMeta,
+      handleAliasesClosed,
+      shownInvalidAliases,
+      aliases
+    ]
+  );
+  const handleRelationTypeChange = React__default.useCallback(
+    (changedData) => {
+      const { type, widgetId, forceAddAlias, itemId: rowItemId, ...rest } = changedData;
+      const newChanged = { ...changedWidgets };
+      if (!newChanged[currentWidgetId]) {
+        newChanged[currentWidgetId] = {};
+      }
+      let currentRelations;
+      if (rowItemId) {
+        currentRelations = preparedRelations.find(
+          (item) => item.itemId === rowItemId
+        )?.relations;
+      } else {
+        currentRelations = preparedRelations.find(
+          (item) => item.widgetId === widgetId
+        )?.relations;
+      }
+      const relationSubjectId = rowItemId || widgetId;
+      const currentRelationType = currentRelations?.type;
+      if (currentRelationType === type) {
+        if (newChanged[currentWidgetId][relationSubjectId] || newChanged[relationSubjectId]?.[currentWidgetId]) {
+          setChangedWidgets(newChanged);
+          delete newChanged[currentWidgetId][relationSubjectId];
+          delete newChanged[relationSubjectId][currentWidgetId];
+        }
+      } else {
+        newChanged[currentWidgetId][relationSubjectId] = type;
+        const pairedType = getPairedRelationType(type);
+        if (pairedType !== RELATION_TYPES.unknown) {
+          newChanged[relationSubjectId] = newChanged[relationSubjectId] ? { ...newChanged[relationSubjectId], [currentWidgetId]: pairedType } : { [currentWidgetId]: pairedType };
+        }
+      }
+      const changeFromUnknown = currentRelationType === RELATION_TYPES.unknown;
+      const showAddAliasForm = type !== RELATION_TYPES.ignore && (changeFromUnknown && forceAddAlias || !changeFromUnknown && currentRelationType === RELATION_TYPES.ignore && type !== RELATION_TYPES.unknown || forceAddAlias);
+      if (showAddAliasForm) {
+        if (!isEmpty(newChanged[currentWidgetId][relationSubjectId])) {
+          const hasRelationBy = hasConnectionsBy(currentRelations);
+          if (hasRelationBy && !forceAddAlias) {
+            setChangedWidgets(newChanged);
+          } else {
+            handleAliasesClick({
+              ...rest,
+              forceAddAlias: true,
+              changedWidgetsData: newChanged,
+              changedWidgetId: widgetId,
+              changedItemId: rowItemId
+            });
+          }
+        }
+      } else {
+        setChangedWidgets(newChanged);
+      }
+    },
+    [changedWidgets, currentWidgetId, preparedRelations, handleAliasesClick]
+  );
+  const handleInvalidAliasesClear = React__default.useCallback(() => {
+    const filteredAliases = aliases[DEFAULT_ALIAS_NAMESPACE].map((aliasRow) => {
+      return aliasRow.filter((item) => !shownInvalidAliases?.includes(item));
+    }).filter((item) => item.length > 1);
+    handleUpdateAliases(filteredAliases);
+    setShownInvalidAliases([]);
+  }, [aliases, handleUpdateAliases, shownInvalidAliases]);
+  const handleDisconnectAll = React__default.useCallback(
+    (disconnectType) => {
+      const newChangedWidgets = { ...changedWidgets };
+      if (!newChangedWidgets[currentWidgetId]) {
+        newChangedWidgets[currentWidgetId] = {};
+      }
+      const filteredIds = filteredRelations.reduce((res, item) => {
+        const widgetId = item.itemId || item.widgetId;
+        if (!widgetId) {
+          return res;
+        }
+        const isControl2 = item.type === DashTabItemType.Control || item.type === DashTabItemType.GroupControl;
+        if (disconnectType === "all" || disconnectType === "selectors" && isControl2 || disconnectType === "charts" && !isControl2) {
+          res[widgetId] = widgetId;
+          if (!newChangedWidgets[widgetId]) {
+            newChangedWidgets[widgetId] = {};
+          }
+        }
+        return res;
+      }, {});
+      preparedRelations.forEach((item) => {
+        const widgetId = item.itemId || item.widgetId;
+        if (filteredIds[widgetId]) {
+          newChangedWidgets[currentWidgetId][widgetId] = RELATION_TYPES.ignore;
+          newChangedWidgets[widgetId][currentWidgetId] = RELATION_TYPES.ignore;
+        }
+      });
+      setChangedWidgets(newChangedWidgets);
+    },
+    [changedWidgets, currentWidgetId, filteredRelations, preparedRelations]
+  );
+  const handleSaveRelations = React__default.useCallback(() => {
+    if (!dashKitRef.current) {
+      return;
+    }
+    if (isLoading) {
+      onClose();
+    }
+    const newData = {};
+    if (changedWidgets) {
+      const connections = getRelationsForSave({
+        changed: changedWidgets,
+        dashkitData: dashKitRef.current || null
+      });
+      if (connections) {
+        newData.connections = connections;
+      }
+    }
+    if (!isEqual(aliases, dashTabAliases || {})) {
+      newData.aliases = isEmpty(aliases?.[DEFAULT_ALIAS_NAMESPACE]) ? {} : aliases;
+    }
+    if (isEmpty(newData)) {
+      onClose();
+    } else {
+      onApply(newData);
+    }
+  }, [dashKitRef, isLoading, changedWidgets, aliases, dashTabAliases, onClose, onApply]);
+  const handleAliasesWarnClick = () => setAliasWarnPopupOpen(!aliasWarnPopupOpen);
+  const isDisconnectDisabled = Boolean(
+    isLoading || typeValues.length === 1 && typeValues[0] === "none" || !filteredRelations.length
+  );
+  React__default.useEffect(() => {
+    if (!preparedRelations?.length && relations.length) {
+      setPreparedRelations(relations);
+    }
+  }, [relations, preparedRelations]);
+  React__default.useEffect(() => {
+    if (!shownInvalidAliases && invalidAliases?.length) {
+      setShownInvalidAliases(invalidAliases);
+    }
+  }, [shownInvalidAliases, invalidAliases]);
+  return /* @__PURE__ */ jsxs(
+    Dialog,
+    {
+      onClose,
+      open: true,
+      className: b$3(),
+      onEnterKeyDown: handleSaveRelations,
+      disableOutsideClick: true,
+      disableEscapeKeyDown: true,
+      children: [
+        /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n$3("title_links") }),
+        /* @__PURE__ */ jsxs(Dialog.Body, { className: b$3("container"), children: [
+          /* @__PURE__ */ jsx(
+            Select,
+            {
+              qa: DashCommonQa.RelationsWidgetSelect,
+              placeholder: i18n$3("label_empty-state"),
+              className: b$3("item-select", {
+                "empty-state": !currentWidget
+              }),
+              popupClassName: b$3("item-select-popup"),
+              value: currentWidgetId ? [currentWidgetId] : void 0,
+              options: widgetOptions,
+              onUpdate: handleItemChange,
+              filterable: true,
+              disabled: isLoading,
+              renderOption: renderOptions,
+              renderSelectedOption: renderOptions,
+              popupWidth: "fit"
+            }
+          ),
+          currentWidget ? /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              Filters,
+              {
+                onChangeInput: handleFilterInputChange,
+                onChangeButtons: handleFilterTypesChange
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Content,
+              {
+                relations: filteredRelations,
+                widgetMeta: currentWidgetMeta,
+                isLoading,
+                onChange: handleRelationTypeChange,
+                onAliasClick: handleAliasesClick,
+                showDebugInfo,
+                widgetIcon: widgetsIconMap[currentWidgetMeta?.widgetId || ""]
+              }
+            )
+          ] }) : /* @__PURE__ */ jsx(EmptyState, {})
+        ] }),
+        /* @__PURE__ */ jsx(
+          Dialog.Footer,
+          {
+            preset: "default",
+            showError: false,
+            textButtonCancel: i18n$3("button_cancel"),
+            textButtonApply: i18n$3("button_apply"),
+            propsButtonCancel: { view: "outlined", qa: DashCommonQa.RelationsCancelBtn },
+            onClickButtonApply: handleSaveRelations,
+            onClickButtonCancel: onClose,
+            propsButtonApply: {
+              qa: DashCommonQa.RelationsApplyBtn
+            },
+            children: currentWidget && /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+              /* @__PURE__ */ jsx("span", { className: b$3("disconnect-text"), children: i18n$3("button_disconnect") }),
+              /* @__PURE__ */ jsx(
+                DropdownMenu,
+                {
+                  disabled: isDisconnectDisabled,
+                  size: "l",
+                  items: [
+                    {
+                      action: () => handleDisconnectAll("all"),
+                      text: i18n$3("label_all"),
+                      qa: DashCommonQa.RelationsDisconnectAllWidgets
+                    },
+                    {
+                      action: () => handleDisconnectAll("charts"),
+                      text: i18n$3("label_charts"),
+                      qa: DashCommonQa.RelationsDisconnectAllCharts
+                    },
+                    {
+                      action: () => handleDisconnectAll("selectors"),
+                      text: i18n$3("label_selectors"),
+                      qa: DashCommonQa.RelationsDisconnectAllSelectors
+                    }
+                  ],
+                  renderSwitcher: ({ onClick, onKeyDown }) => /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      className: b$3("switcher-button"),
+                      view: "normal",
+                      qa: DashCommonQa.RelationsDisconnectAllSwitcher,
+                      disabled: isDisconnectDisabled,
+                      onClick,
+                      onKeyDown,
+                      children: /* @__PURE__ */ jsx(
+                        Icon,
+                        {
+                          className: b$3("switcher-button-icon"),
+                          data: ChevronDown,
+                          size: ICON_SIZE
+                        }
+                      )
+                    }
+                  )
+                }
+              ),
+              Boolean(shownInvalidAliases?.length) && /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+                /* @__PURE__ */ jsx(
+                  Button,
+                  {
+                    ref: aliasWarnButtonRef,
+                    className: b$3("error-button"),
+                    onClick: handleAliasesWarnClick,
+                    view: "flat",
+                    children: /* @__PURE__ */ jsx(
+                      Icon,
+                      {
+                        data: TriangleExclamationFill,
+                        className: b$3("error-icon")
+                      }
+                    )
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Popup,
+                  {
+                    hasArrow: true,
+                    anchorElement: aliasWarnButtonRef.current,
+                    open: aliasWarnPopupOpen,
+                    placement: "right",
+                    className: b$3("invalid-list-popup"),
+                    children: /* @__PURE__ */ jsxs("div", { className: b$3("warn-content"), children: [
+                      /* @__PURE__ */ jsx("div", { className: b$3("warn-title"), children: i18n$3("label_invalid-alias-title") }),
+                      /* @__PURE__ */ jsx("div", { className: b$3("warn-text"), children: i18n$3("label_invalid-alias-text") }),
+                      /* @__PURE__ */ jsx(
+                        AliasesInvalidList,
+                        {
+                          aliases: aliases?.[DEFAULT_ALIAS_NAMESPACE],
+                          invalidAliases: shownInvalidAliases,
+                          datasets,
+                          onClose: handleAliasesWarnClick,
+                          onClear: handleInvalidAliasesClear
+                        }
+                      )
+                    ] })
+                  }
+                )
+              ] })
+            ] })
+          }
+        )
+      ]
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_RELATIONS, DialogRelations);
+const isAddingAliasExists = (currentAliasRow, newAlias) => {
+  if (currentAliasRow.length < newAlias.length) {
+    return false;
+  }
+  const currentAliasDict = {};
+  currentAliasRow.forEach((item) => {
+    currentAliasDict[item] = item;
+  });
+  let counter = 0;
+  newAlias.forEach((item) => {
+    if (item in currentAliasDict) {
+      counter++;
+    }
+  });
+  return counter === newAlias.length;
+};
+const hasAliasWithSameDataset = (addedAliases, datasets) => {
+  if (!datasets) {
+    return false;
+  }
+  const datasetsFields = {};
+  for (const [datasetId, datasetData] of Object.entries(datasets)) {
+    datasetsFields[datasetId] = datasetData.fields.reduce((previousValue, currentValue) => {
+      return { ...previousValue, [currentValue.guid]: currentValue.guid };
+    }, {});
+  }
+  const datasetEntries = Object.entries(datasetsFields);
+  for (let i = 0; i < addedAliases.length; i++) {
+    if (addedAliases[i].length < 3) {
+      continue;
+    }
+    const fieldsByDataset = {};
+    let hasErrors = false;
+    for (let j = 0; j < addedAliases[i].length; j++) {
+      const field = addedAliases[i][j];
+      for (const [id, datasetFields] of datasetEntries) {
+        if (field in datasetFields) {
+          if (fieldsByDataset[id]) {
+            fieldsByDataset[id].push(field);
+            hasErrors = true;
+          } else {
+            fieldsByDataset[id] = [field];
+          }
+        }
+      }
+    }
+    if (hasErrors) {
+      return {
+        alias: addedAliases[i],
+        errors: Object.values(fieldsByDataset).reduce((memo, fields) => {
+          if (fields.length > 1) {
+            memo.push(...fields);
+          }
+          return memo;
+        }, [])
+      };
+    }
+  }
+  return false;
+};
+const getParamsSelectOptions = (item) => ({ content: item, value: item });
+const i18n$2 = I18n.keyset("component.dialog-relations.view");
+const b$2 = block("dialog-aliases-add");
+const getList = (data) => {
+  const dataset = data.datasets?.length ? data.datasets[0] : null;
+  let res = [];
+  if (dataset?.fieldsList && !data.isQL) {
+    res = dataset?.fieldsList.filter((item) => isControl(data) ? item.guid in (data.defaultParams || {}) : true).map((item) => ({
+      content: item.title,
+      value: item.guid
+    }));
+  } else {
+    if (isEditorChart(data)) {
+      return !data.params || isEmpty(data.params) ? [] : Object.keys(data.params).map(getParamsSelectOptions);
+    } else if (isExternalControl(data)) {
+      return !data.widgetParams || isEmpty(data.widgetParams) ? [] : Object.keys(data.widgetParams).map(getParamsSelectOptions);
+    }
+    res = data.usedParams?.map(getParamsSelectOptions) || [];
+  }
+  return res;
+};
+const getFieldName = (data, selectedItem) => {
+  const datasetFields = data.datasets?.length && !data.isQL ? data.datasets[0]?.fieldsList : null;
+  if (!datasetFields) {
+    return /* @__PURE__ */ jsx("div", { children: selectedItem?.value || "" });
+  }
+  return /* @__PURE__ */ jsx("div", { children: datasetFields.find((item) => item.guid === selectedItem?.value)?.title || selectedItem?.value || "" });
+};
+const getDatasetName = (data, datasets) => {
+  const dataset = data.datasets?.length ? data.datasets[0] : null;
+  if (!dataset || !datasets) {
+    return "";
+  }
+  const datasetId = data.datasetId || dataset.id;
+  return datasetId in datasets && datasets[datasetId].name || "";
+};
+const prepareData = (data, datasets) => {
+  const options = getList(data);
+  options.sort((prevItem, item) => prevItem.content.localeCompare(item.content));
+  const name = getDatasetName(data, datasets);
+  const subTitle = name ? `${data.title || data.label} (${name})` : data.title || data.label;
+  return { options, subTitle };
+};
+const AddAliases = ({
+  widget,
+  currentRow,
+  currentAliases,
+  onCancel,
+  onAdd,
+  widgetIcon,
+  rowIcon,
+  error
+}) => {
+  const { datasets } = React__default.useContext(AliasesContext);
+  const [errorMsg, setErrorMgs] = React__default.useState("");
+  const [errorAliases, setErrorAliases] = React__default.useState(null);
+  const [leftAliasSelected, setLeftAliasSelected] = React__default.useState();
+  const [rightAliasSelected, setRightAliasSelected] = React__default.useState();
+  const { options: currentItemOptions, subTitle: leftAliasSubTitle } = prepareData(
+    widget,
+    datasets
+  );
+  const { options: rowItemOptions, subTitle: rightAliasSubTitle } = prepareData(
+    currentRow,
+    datasets
+  );
+  const handleSelectLeftAlias = React__default.useCallback((value) => {
+    setLeftAliasSelected(value);
+  }, []);
+  const handleSelectRightAlias = React__default.useCallback((value) => {
+    setRightAliasSelected(value);
+  }, []);
+  const handleAddAlias = React__default.useCallback(() => {
+    setErrorMgs("");
+    if (leftAliasSelected === void 0 || rightAliasSelected === void 0) {
+      setErrorMgs(i18n$2("label_choose-fields-from-list"));
+      return;
+    }
+    let newAlias = [];
+    if (Array.isArray(leftAliasSelected)) {
+      newAlias = [...newAlias, ...leftAliasSelected];
+    } else {
+      newAlias.push(leftAliasSelected);
+    }
+    if (Array.isArray(rightAliasSelected)) {
+      newAlias = [...newAlias, ...rightAliasSelected];
+    } else {
+      newAlias.push(rightAliasSelected);
+    }
+    newAlias.sort();
+    if (newAlias[0] === newAlias[1]) {
+      setErrorMgs(i18n$2("label_alias-same-dataset-field"));
+      return;
+    }
+    for (let i = 0; i < currentAliases.length; i++) {
+      if (isAddingAliasExists(currentAliases[i], newAlias)) {
+        setErrorMgs(i18n$2("label_alias-already-exists"));
+        return;
+      }
+    }
+    const addedAliases = addAlias(newAlias[0], newAlias[1], [...currentAliases]);
+    const sameDatasetAlias = hasAliasWithSameDataset(addedAliases, datasets);
+    if (sameDatasetAlias) {
+      setErrorMgs(i18n$2("label_alias-same-dataset"));
+      setErrorAliases(sameDatasetAlias);
+      return;
+    } else {
+      setErrorAliases(null);
+    }
+    onAdd(newAlias);
+    setLeftAliasSelected(void 0);
+    setRightAliasSelected(void 0);
+  }, [currentAliases, leftAliasSelected, rightAliasSelected, onAdd, datasets]);
+  React__default.useEffect(() => {
+    if (!error?.trim()) {
+      return;
+    }
+    setErrorMgs(error);
+  }, [error]);
+  if (!currentItemOptions.length || !rowItemOptions.length) {
+    const hasExternalControl = isExternalControl(widget) || isExternalControl(currentRow);
+    const keyset = hasExternalControl ? i18n$2("label_need-default-external-control") : i18n$2("label_need-default-editor-chart");
+    const linkParam = hasExternalControl ? "/editor/widgets/selector/external" : "/operations/chart/add-parameters";
+    return /* @__PURE__ */ jsx("div", { className: b$2(), children: /* @__PURE__ */ jsx(
+      Interpolate,
+      {
+        text: keyset,
+        matches: {
+          link: (match) => /* @__PURE__ */ jsx(React__default.Fragment, { children: /* @__PURE__ */ jsx(
+            Link,
+            {
+              href: `${DL.ENDPOINTS.datalensDocs}${linkParam}`,
+              target: "_blank",
+              children: match
+            }
+          ) })
+        }
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: b$2(), children: [
+    /* @__PURE__ */ jsxs("div", { className: b$2("row"), children: [
+      /* @__PURE__ */ jsxs("div", { className: b$2("select-wrap"), children: [
+        /* @__PURE__ */ jsxs("div", { className: b$2("sub-title"), title: leftAliasSubTitle, children: [
+          /* @__PURE__ */ jsx("div", { className: b$2("icon"), children: widgetIcon }),
+          leftAliasSubTitle
+        ] }),
+        /* @__PURE__ */ jsx(
+          Select,
+          {
+            filterable: true,
+            size: "m",
+            options: currentItemOptions,
+            className: b$2("select"),
+            placeholder: i18n$2("label_choose-field-for-alias"),
+            onUpdate: handleSelectLeftAlias,
+            value: leftAliasSelected === void 0 ? [] : leftAliasSelected,
+            popupClassName: b$2("dialog-popup"),
+            renderSelectedOption: (value) => getFieldName(widget, value),
+            qa: DashCommonQa.AliasSelectLeft
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("span", { className: b$2("eq"), children: "=" }),
+      /* @__PURE__ */ jsxs("div", { className: b$2("select-wrap"), children: [
+        /* @__PURE__ */ jsxs("div", { className: b$2("sub-title"), title: rightAliasSubTitle, children: [
+          /* @__PURE__ */ jsx("div", { className: b$2("icon"), children: rowIcon }),
+          rightAliasSubTitle
+        ] }),
+        /* @__PURE__ */ jsx(
+          Select,
+          {
+            filterable: true,
+            size: "m",
+            options: rowItemOptions,
+            className: b$2("select"),
+            placeholder: i18n$2("label_choose-field-for-alias"),
+            onUpdate: handleSelectRightAlias,
+            value: rightAliasSelected === void 0 ? [] : rightAliasSelected,
+            popupClassName: b$2("dialog-popup"),
+            renderSelectedOption: (value) => getFieldName(currentRow, value),
+            qa: DashCommonQa.AliasSelectRight
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx(Button, { className: b$2("button"), view: "normal", onClick: onCancel, children: /* @__PURE__ */ jsx(Icon, { data: Xmark }) }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: b$2("button"),
+          view: "action",
+          onClick: handleAddAlias,
+          qa: DashCommonQa.AliasAddBtn,
+          children: /* @__PURE__ */ jsx(Icon, { data: Check })
+        }
+      )
+    ] }),
+    errorMsg && /* @__PURE__ */ jsx("div", { className: b$2("error"), children: errorMsg }),
+    errorAliases && /* @__PURE__ */ jsx(
+      AliasesInvalidList,
+      {
+        aliases: [errorAliases.alias],
+        invalidAliases: errorAliases.errors,
+        datasets
+      }
+    )
+  ] });
+};
+const b$1 = block("dialog-aliases-detail");
+const i18n$1 = I18n.keyset("component.dialog-relations.view");
+const AliasesDetail = ({ fieldName, items }) => {
+  const { showDebugInfo, invalidAliases } = React__default.useContext(AliasesContext);
+  let content = items.map((item, index) => {
+    const icon = getRelationsIcon(item, b$1("details-icon"));
+    const label = item?.label && item?.label !== item.title ? item?.label : "";
+    const debugInfo = showDebugInfo ? /* @__PURE__ */ jsxs("span", { className: b$1("info"), children: [
+      " (",
+      item.widgetId,
+      ")"
+    ] }) : null;
+    const title = (showDebugInfo ? `(${item.widgetId}) ` : "") + label + item.title;
+    const rowTitle = [label, item.title].filter(Boolean).join(` — `);
+    return {
+      node: /* @__PURE__ */ jsxs("div", { className: b$1("row"), children: [
+        icon,
+        /* @__PURE__ */ jsxs("span", { className: b$1("text"), title, children: [
+          debugInfo,
+          rowTitle
+        ] })
+      ] }, `linked-widgets-row-${item.widgetId}-${index}`),
+      text: rowTitle
+    };
+  }).sort((prevItem, item) => prevItem.text.localeCompare(item.text)).map((item) => item.node);
+  if (invalidAliases?.includes(fieldName)) {
+    content = /* @__PURE__ */ jsx("div", { className: b$1("error"), children: i18n$1("label_invalid-alias") });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: b$1(), children: [
+    /* @__PURE__ */ jsx("div", { className: b$1("subtitle"), children: i18n$1("label_alias-detail-1") + fieldName ? ` ${i18n$1("label_alias-detail-2")} ${fieldName}` : "" }),
+    /* @__PURE__ */ jsx("div", { className: b$1("content"), children: content })
+  ] });
+};
+const DIALOG_ALIASES = /* @__PURE__ */ Symbol("dash/DIALOG_ALIASES");
+const b = block("dialog-aliases");
+const i18n = I18n.keyset("component.dialog-aliases.view");
+const DialogAliases = (props) => {
+  const {
+    onClose,
+    relations,
+    currentRow,
+    currentWidget,
+    showDebugInfo,
+    datasets,
+    updateAliases,
+    relationText,
+    relationType,
+    widgetIcon,
+    rowIcon,
+    forceAddAlias,
+    changedWidgetsData,
+    changedWidgetId,
+    changedItemId,
+    invalidAliases,
+    dialogAliases
+  } = props;
+  const [showDetailedData, setShowDetailedData] = React__default.useState(false);
+  const [selectedAliasRowIndex, setSelectedAliasRowIndex] = React__default.useState(null);
+  const [showAddAlias, setShowAddAlias] = React__default.useState(
+    Boolean(forceAddAlias) || false
+  );
+  const [enableAddAlias, setEnableAddAlias] = React__default.useState(true);
+  const [aliasAdded, setAliasAdded] = React__default.useState([]);
+  const [aliasRequired, setAliasRequired] = React__default.useState(false);
+  const [selectedFieldName, setSelectedFieldName] = React__default.useState(null);
+  const [selectedParam, setSelectedParam] = React__default.useState(null);
+  const [currentAlias, setCurrentAlias] = React__default.useState(null);
+  const [dashTabAliasesByNamespace, setAliasesByNamespace] = React__default.useState(
+    dialogAliases?.[DEFAULT_ALIAS_NAMESPACE] || []
+  );
+  const [aliases, setAliases] = React__default.useState(currentRow.relations.byAliases.sort());
+  const hasAlias = Boolean(aliases.length);
+  const aliasRequiredErrorText = aliasRequired ? i18n("label_required-add-alias") : void 0;
+  const caption = /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    i18n("title_add-alias"),
+    /* @__PURE__ */ jsxs(HelpMark, { className: b("info"), children: [
+      /* @__PURE__ */ jsx("p", { className: b("info-text"), children: i18n("label_info_1") }),
+      /* @__PURE__ */ jsx("p", { className: b("info-text"), children: i18n("label_info_2") })
+    ] })
+  ] });
+  const isIgnored = relationType === RELATION_TYPES.ignore;
+  const isBoth = relationType === RELATION_TYPES.both;
+  const affectedItems = [currentWidget, ...relations].map((item) => ({
+    ...item,
+    intersectionParams: intersection(item.usedParams, currentAlias)
+  })).filter(
+    ({ intersectionParams }) => intersectionParams.length && (!selectedParam || intersectionParams.includes(selectedParam))
+  );
+  const hasUsedParams = Boolean(currentWidget.usedParams?.length) && Boolean(currentRow.usedParams?.length);
+  const showAddAliasButton = hasUsedParams && enableAddAlias && (!isIgnored || isIgnored && forceAddAlias);
+  const showAlert = !enableAddAlias || !hasUsedParams;
+  let alertText = null;
+  if (!hasUsedParams) {
+    alertText = i18n("label_card-used-params");
+  } else if (!enableAddAlias) {
+    alertText = i18n("label_card");
+  }
+  const disableApplyButton = isIgnored && !forceAddAlias && !currentRow.relations.byAliases.length || isIgnored && forceAddAlias && !aliases.length;
+  const resetSelectedAliasRow = React__default.useCallback(() => {
+    setSelectedParam(null);
+    setSelectedFieldName(null);
+    setShowDetailedData(false);
+    setSelectedAliasRowIndex(null);
+    setCurrentAlias(null);
+  }, []);
+  const handleDetailedAlias = React__default.useCallback(
+    (data) => {
+      const { field, fieldName, indexRow, aliasRow, isClickedOnSelected } = data;
+      if (isClickedOnSelected) {
+        resetSelectedAliasRow();
+        return;
+      }
+      setSelectedParam(field?.guid || fieldName || null);
+      setSelectedFieldName(fieldName);
+      setShowDetailedData(true);
+      setSelectedAliasRowIndex(indexRow);
+      setCurrentAlias(aliasRow);
+    },
+    [resetSelectedAliasRow]
+  );
+  const handleDetailClick = React__default.useCallback(
+    ({ indexRow, aliasRow }) => {
+      setSelectedParam(null);
+      setSelectedFieldName(null);
+      setShowDetailedData(!showDetailedData);
+      setSelectedAliasRowIndex(showDetailedData ? null : indexRow);
+      setCurrentAlias(showDetailedData ? null : aliasRow);
+    },
+    [showDetailedData]
+  );
+  const handleRemoveAlias = React__default.useCallback(
+    ({
+      row: aliasesForRemove,
+      rowWithPartlyRemoved
+    }) => {
+      const aliasesForRemoveSorted = [...aliasesForRemove].sort();
+      const filterAliases = (list, item) => {
+        if (isEqual([...item].sort(), aliasesForRemoveSorted)) {
+          if (rowWithPartlyRemoved?.length) {
+            list.push(rowWithPartlyRemoved);
+          }
+        } else {
+          list.push(item);
+        }
+        return list;
+      };
+      const filteredAliases = aliases.reduce(filterAliases, []);
+      const dashTabFilteredAliases = dashTabAliasesByNamespace.reduce(filterAliases, []);
+      let count = 0;
+      aliasAdded.forEach((item) => {
+        if (aliasesForRemove.includes(item)) {
+          count++;
+        }
+      });
+      if (count === aliasAdded.length) {
+        setAliasAdded([]);
+      }
+      setAliases(filteredAliases.sort());
+      setAliasesByNamespace(dashTabFilteredAliases);
+      resetSelectedAliasRow();
+    },
+    [dashTabAliasesByNamespace, aliasAdded, aliases, resetSelectedAliasRow]
+  );
+  const handleAddNewAliases = React__default.useCallback(
+    (alias) => {
+      setShowAddAlias(false);
+      setAliases(getNormalizedAliases([...aliases, alias]));
+      setAliasesByNamespace(getNormalizedAliases([...dashTabAliasesByNamespace, alias]));
+      setAliasAdded(alias);
+    },
+    [aliases, dashTabAliasesByNamespace]
+  );
+  const handleApplyChanges = React__default.useCallback(() => {
+    if (forceAddAlias && !aliasAdded.length) {
+      setAliasRequired(true);
+      setShowAddAlias(true);
+      return;
+    }
+    updateAliases(getNormalizedAliases(dashTabAliasesByNamespace));
+    onClose({
+      ...changedWidgetsData ? { changedWidgetsData } : {},
+      ...changedWidgetId ? { changedWidgetId } : {},
+      ...changedItemId ? { changedItemId } : {},
+      ...dashTabAliasesByNamespace ? { aliases: dashTabAliasesByNamespace } : {}
+    });
+  }, [
+    forceAddAlias,
+    aliasAdded,
+    updateAliases,
+    dashTabAliasesByNamespace,
+    onClose,
+    changedWidgetsData,
+    changedWidgetId
+  ]);
+  const handleAddAlias = React__default.useCallback(() => {
+    setShowAddAlias(true);
+  }, []);
+  const handleHideAlias = React__default.useCallback(() => {
+    setShowAddAlias(false);
+  }, []);
+  const handleCancel = React__default.useCallback(() => {
+    onClose({
+      reset: true
+    });
+  }, [onClose]);
+  React__default.useEffect(() => {
+    const widgetDatasetId = currentWidget.datasetId || (currentWidget.datasets?.length ? currentWidget.datasets[0].id || "" : "");
+    const currentRowDatasetId = currentRow.datasetId || (currentRow.datasets?.length ? currentRow.datasets[0].id || "" : "");
+    if (widgetDatasetId && currentRowDatasetId && widgetDatasetId === currentRowDatasetId) {
+      setEnableAddAlias(false);
+    }
+  }, [currentWidget, currentRow]);
+  React__default.useEffect(() => {
+    setAliasRequired(false);
+    if (!forceAddAlias) {
+      return;
+    }
+    if (!aliasAdded.length) {
+      setShowAddAlias(true);
+      setAliasRequired(true);
+    }
+  }, [forceAddAlias, aliasAdded]);
+  React__default.useEffect(() => {
+    setAliases(currentRow.relations.byAliases.sort());
+  }, [currentRow]);
+  return /* @__PURE__ */ jsxs(Dialog, { onClose: handleCancel, open: true, className: b(), children: [
+    /* @__PURE__ */ jsx(Dialog.Header, { caption }),
+    /* @__PURE__ */ jsx(Dialog.Body, { className: b("container"), children: /* @__PURE__ */ jsxs(
+      AliasesContext.Provider,
+      {
+        value: {
+          datasets,
+          showDebugInfo,
+          relations,
+          selectedAliasRowIndex,
+          selectedParam,
+          invalidAliases
+        },
+        children: [
+          relationText && /* @__PURE__ */ jsxs("div", { className: b("sub-header"), children: [
+            /* @__PURE__ */ jsxs("span", { className: b("label"), children: [
+              i18n("label_link-type"),
+              ":"
+            ] }),
+            /* @__PURE__ */ jsx("span", { className: b("type-text", { "lower-case": isBoth || isIgnored }), children: relationText })
+          ] }),
+          showAlert && alertText && /* @__PURE__ */ jsx(
+            Alert,
+            {
+              theme: "warning",
+              message: alertText,
+              className: b("card"),
+              view: "outlined"
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: b("controls"), children: hasAlias ? /* @__PURE__ */ jsx(React__default.Fragment, { children: /* @__PURE__ */ jsx(
+            Collapse,
+            {
+              arrowPosition: "left",
+              title: i18n("label_collapse-label"),
+              arrowView: "icon",
+              isSecondary: true,
+              className: b("collapse-list"),
+              titleSize: "s",
+              contentClassName: b("collapse-list-content"),
+              arrowQa: DashCommonQa.AliasesListCollapse,
+              children: /* @__PURE__ */ jsx(
+                AliasesList,
+                {
+                  widgetId: currentRow.widgetId,
+                  aliases,
+                  onAliasRowClick: handleDetailedAlias,
+                  onDetailClick: handleDetailClick,
+                  onRemoveClick: handleRemoveAlias,
+                  showDetailedData
+                }
+              )
+            }
+          ) }) : /* @__PURE__ */ jsx("div", { className: b("empty"), children: i18n("label_empty") }) }),
+          hasAlias && showDetailedData && /* @__PURE__ */ jsx(
+            AliasesDetail,
+            {
+              fieldName: selectedFieldName || "",
+              items: affectedItems,
+              widget: currentWidget,
+              currentRow
+            }
+          ),
+          showAddAliasButton && /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+            !showAddAlias && /* @__PURE__ */ jsxs(Button, { onClick: handleAddAlias, children: [
+              /* @__PURE__ */ jsx(Icon, { data: Plus }),
+              i18n("button_add-alias")
+            ] }),
+            showAddAlias && /* @__PURE__ */ jsx(
+              AddAliases,
+              {
+                widget: currentWidget,
+                currentRow,
+                onCancel: handleHideAlias,
+                currentAliases: aliases,
+                onAdd: handleAddNewAliases,
+                widgetIcon,
+                rowIcon,
+                error: aliasRequiredErrorText
+              }
+            )
+          ] })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      Dialog.Footer,
+      {
+        preset: "default",
+        showError: false,
+        textButtonCancel: i18n("button_cancel"),
+        textButtonApply: i18n("button_apply"),
+        propsButtonApply: { disabled: disableApplyButton, qa: DashCommonQa.AliasAddApplyBtn },
+        propsButtonCancel: { view: "outlined", qa: DashCommonQa.AliasesCancelBtn },
+        onClickButtonApply: handleApplyChanges,
+        onClickButtonCancel: handleCancel
+      }
+    )
+  ] });
+};
+DialogManager.registerDialog(DIALOG_ALIASES, DialogAliases);
+const openDialogRelations = ({
+  widget,
+  dashKitRef,
+  onApply,
+  onClose
+}) => {
+  return function(dispatch, getState) {
+    const state = getState();
+    const dashTabAliases = selectCurrentTabAliases(state);
+    const workbookId = selectDashWorkbookId(state);
+    const allWidgets = selectCurrentTabRelationDataItems(state);
+    const widgetsCurrentTab = selectWidgetsCurrentTab(state);
+    const openDialogRelationsParams = {
+      onClose: () => {
+        onClose();
+        dispatch(closeDialog());
+      },
+      onApply: (newData) => {
+        onApply?.();
+        updateCurrentTabData(newData)(dispatch);
+        onClose();
+        dispatch(closeDialog());
+      },
+      widget,
+      dashKitRef,
+      dashTabAliases,
+      widgetsCurrentTab,
+      workbookId,
+      allWidgets
+    };
+    dispatch(
+      openDialog({
+        id: DIALOG_RELATIONS,
+        props: openDialogRelationsParams
+      })
+    );
+  };
+};
+const openDialogAliases = (props) => {
+  return function(dispatch) {
+    const openDialogAliasesParams = {
+      ...props,
+      onClose: (args) => {
+        if (typeof props.onCloseCallback === "function") {
+          props.onCloseCallback(args);
+        }
+        dispatch(closeDialog());
+      }
+    };
+    dispatch(
+      openDialog({
+        id: DIALOG_ALIASES,
+        props: openDialogAliasesParams
+      })
+    );
+  };
+};
+const openEmptyDialogRelations = () => {
+  return function(dispatch, getState) {
+    const state = getState();
+    const dashKitRef = selectDashkitRef(state);
+    if (dashKitRef === null) {
+      return;
+    }
+    batch(() => {
+      openDialogRelations({
+        dashKitRef,
+        onClose: () => {
+        }
+      })(dispatch, getState);
+    });
+  };
+};
+export {
+  openDialogRelations as a,
+  openEmptyDialogRelations as o
+};