@retailcrm/datalens-ui 0.0.0 → 0.1.0

package/components/Widgets.js

@@ -1,3964 +0,0 @@
-import React__default, { createElement } from "react";
-import { aZ as getExportMenuItem, a_ as getNewWindowMenuItem, a$ as getInspectorMenuItem, b0 as getEditMenuItem, b1 as getOpenAsTableMenuItem, b2 as getFullscreenMenuItem, b3 as prepareValues, D as DASH_WIDGET_TYPES, b4 as ERROR_CODE, b5 as settings_default, b6 as MenuWithErrorBoundary, b7 as drawComments, b8 as hideComments, b9 as ChartsInsights, ba as ChartkitError, bb as ChartKitAdapter, bc as setSkipReload, bd as getRandomCKId, be as ExtensionsManager, bf as Loader, bg as Drill, bh as SideMarkdown, bi as ChartsDataProvider, bj as formatError, bk as DatalensChartkitCustomError, bl as isEmbeddedMode, bm as START_PAGE, bn as getDataProviderData, bo as selectSkipReload, g as chartsDataProvider } from "./ControlComponents.js";
-import { jsx, jsxs } from "react/jsx-runtime";
-import block from "bem-cn-lite";
-import isEqual from "lodash/isEqual";
-import omit from "lodash/omit";
-import pick from "lodash/pick";
-import { aR as MenuItemsIds, r as registry, F as Feature, j as i18n, D as DL, aT as FOCUSED_WIDGET_PARAM_NAME, cQ as isTrueArg, U as URL_OPTIONS, b3 as ControlQA, b as SHARED_URL_OPTIONS, ah as DashTabItemControlSourceType, aN as ChartkitMenuDialogsQA, u as DashTabItemType } from "./AccessRights.js";
-import { i as isWidgetTypeDoNotNeedOverlay, d as isExternalControl, e as adjustWidgetLayout, f as DebugInfoTool, E as ExtendedDashKitContext, u as useBeforeLoad } from "./DashKit.js";
-import { useDispatch, useSelector } from "react-redux";
-import { Popover, Icon, Button, Loader as Loader$1, Link } from "@gravity-ui/uikit";
-import get from "lodash/get";
-import { ShieldExclamation, ArrowLeft } from "@gravity-ui/icons";
-import { u as useMarkdown, M as MarkdownHelpPopover } from "./MarkdownHelpPopover.js";
-import { i as isEnabledFeature, z as getRouter, P as toSearchParams, U as Utils, aj as selectWorkbookEditPermission, aa as getRenderMarkdownFn, o as openDialog, c as closeDialog, d as showToast, j as useMountedState, Q as usePrevious, l as logger, Y as YFM_MARKDOWN_CLASSNAME, ak as YFM_CUT_MARKDOWN_CLASSNAME } from "./ActionPanel.js";
-import { stringify } from "querystring";
-import { isObject } from "lodash";
-import { g as getGroupedMenu } from "./EntryContextMenu.js";
-import isEmpty from "lodash/isEmpty";
-import { dateTime } from "@gravity-ui/date-utils";
-import { pickActionParamsFromParams, pickExceptActionParamsFromParams } from "@gravity-ui/dashkit/helpers";
-import unescape from "lodash/unescape";
-import { D as DIALOG_DEFAULT } from "./DialogDefault.js";
-import { Y as YfmWrapper } from "./YfmWrapper.js";
-import throttle from "lodash/throttle";
-import debounce from "lodash/debounce";
-import { useHistory, useLocation } from "react-router-dom";
-import { AdaptiveTabs } from "@gravity-ui/components";
-import { a as DL_ADAPTIVE_TABS_BREAK_POINT_CONFIG } from "./DialogFilter.js";
-import { M as MOBILE_SIZE } from "./CollectionFilters.js";
-const getWidgetChartMenu = ({
-  chartsDataProvider: chartsDataProvider2,
-  customOptions,
-  canEdit,
-  extraOptions
-}) => {
-  return [
-    getFullscreenMenuItem(customOptions[MenuItemsIds.FULLSCREEEN]),
-    getExportMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.EXPORT]
-    }),
-    getNewWindowMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.NEW_WINDOW],
-      extraOptions
-    }),
-    getInspectorMenuItem(),
-    canEdit ? getEditMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.EDIT]
-    }) : null
-  ];
-};
-const getWizardChartMenu = ({ chartsDataProvider: chartsDataProvider2, customOptions }) => {
-  return [
-    getExportMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.EXPORT]
-    }),
-    getNewWindowMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.NEW_WINDOW]
-    }),
-    getOpenAsTableMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.OPEN_AS_TABLE]
-    }),
-    getInspectorMenuItem()
-  ];
-};
-const getPanePreviewChartMenu = ({ chartsDataProvider: chartsDataProvider2 }) => {
-  return [
-    getExportMenuItem({
-      chartsDataProvider: chartsDataProvider2
-    }),
-    getInspectorMenuItem()
-  ];
-};
-const getDefaultChartMenu = ({
-  chartsDataProvider: chartsDataProvider2,
-  customOptions,
-  extraOptions
-}) => {
-  const menuItemsGroups = [
-    getExportMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.EXPORT]
-    }),
-    getNewWindowMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.NEW_WINDOW],
-      extraOptions
-    }),
-    getInspectorMenuItem(),
-    getEditMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.EDIT]
-    }),
-    getOpenAsTableMenuItem({
-      chartsDataProvider: chartsDataProvider2,
-      customConfig: customOptions[MenuItemsIds.OPEN_AS_TABLE]
-    })
-  ];
-  return menuItemsGroups;
-};
-const getChartkitMenuItems = (props) => {
-  const { type, config, chartsDataProvider: chartsDataProvider2, extraOptions } = props;
-  const canEdit = config?.canEdit || false;
-  const customOptions = props.customOptions || {};
-  let menuItemsGroups = [];
-  switch (type) {
-    case "widget": {
-      menuItemsGroups = getWidgetChartMenu({ chartsDataProvider: chartsDataProvider2, canEdit, customOptions });
-      break;
-    }
-    case "wizard": {
-      const getWizardChartMenuFn = registry.chart.functions.get("getWizardChartMenu");
-      menuItemsGroups = getWizardChartMenuFn({
-        chartsDataProvider: chartsDataProvider2,
-        customOptions,
-        extraOptions
-      });
-      break;
-    }
-    case "panePreview": {
-      const getPanePreviewChartMenuFn = registry.chart.functions.get("getPanePreviewChartMenu");
-      menuItemsGroups = getPanePreviewChartMenuFn({ chartsDataProvider: chartsDataProvider2 });
-      break;
-    }
-    case "dash":
-    case "preview":
-    default: {
-      const getDefaultChartMenuFn = registry.chart.functions.get("getDefaultChartMenu");
-      menuItemsGroups = getDefaultChartMenuFn({
-        type,
-        chartsDataProvider: chartsDataProvider2,
-        customOptions,
-        extraOptions
-      });
-    }
-  }
-  const filtered = menuItemsGroups.filter(Boolean);
-  return getGroupedMenu(filtered);
-};
-const getChartkitMenuByType = (props) => {
-  const {
-    type,
-    config,
-    customOptions,
-    chartsDataProvider: dataProvider,
-    onExportLoading,
-    onFullscreenClick,
-    isEditAvaible,
-    extraOptions
-  } = props || {};
-  const chartsDataProvider2 = dataProvider;
-  const isEditVisible = isEnabledFeature(Feature.ReadOnlyMode) ? { isVisible: () => false } : isEditAvaible === void 0 ? {} : { isVisible: () => isEditAvaible };
-  return getChartkitMenuItems({
-    type,
-    config,
-    chartsDataProvider: chartsDataProvider2,
-    extraOptions,
-    customOptions: {
-      [MenuItemsIds.NEW_WINDOW]: {
-        title: i18n("dash.chartkit-menu.view", "button_new-tab"),
-        action: ({ propsData: { id, params } }) => {
-          getRouter().openTab({
-            pathname: `/preview/${id}`,
-            search: stringify(params)
-          });
-        }
-      },
-      [MenuItemsIds.OPEN_AS_TABLE]: {
-        action: ({ propsData: { id, params } }) => {
-          const resultParams = isObject(params) ? { ...params } : {};
-          getRouter().openTab({
-            pathname: `/preview/${id}`,
-            search: toSearchParams({ ...resultParams, _chart_type: "table" })
-          });
-        }
-      },
-      [MenuItemsIds.EDIT]: {
-        title: i18n("dash.chartkit-menu.view", "button_edit"),
-        ...isEditVisible
-      },
-      [MenuItemsIds.EXPORT]: {
-        onExportLoading
-      },
-      [MenuItemsIds.FULLSCREEEN]: {
-        onFullscreenClick
-      },
-      ...customOptions
-    }
-  });
-};
-const getChartkitMenu = (props) => {
-  const getChartkitMenuByType2 = registry.chart.functions.get("getChartkitMenuByType");
-  return getChartkitMenuByType2(props);
-};
-const DAY_MS = 1e3 * 60 * 60 * 24;
-function convertChartToTable(options) {
-  const { widget, widgetData } = options;
-  const chartData = prepareValues({
-    widget,
-    data: widgetData?.data,
-    widgetType: widgetData?.type,
-    extra: {}
-  });
-  if (!chartData) {
-    return [];
-  }
-  let lines = [];
-  const header = [];
-  if (chartData.categories_ms) {
-    header.push("DateTime");
-  }
-  if (chartData.categories) {
-    header.push("Categories");
-  }
-  chartData.graphs.forEach((graph) => {
-    header.push(graph.title);
-  });
-  lines.push(header);
-  const dataArray = chartData.categories_ms || chartData.categories || Array(chartData.graphs[0].data.length).fill(void 0);
-  dataArray.forEach((item, i) => {
-    const line = [];
-    if (item) {
-      const diff = item - dataArray[i - 1] || dataArray[i + 1] - item;
-      const format = diff < DAY_MS ? "YYYY-MM-DD HH:mm:ss" : "YYYY-MM-DD";
-      const measure = chartData.categories_ms ? dateTime({
-        input: item
-      }).format(format) : item;
-      line.push(`"${measure}"`);
-    }
-    chartData.graphs.forEach((graph) => {
-      let currentValue = graph.data[i];
-      let value = '""';
-      if (currentValue || currentValue === 0) {
-        if (graph.type === "diff" && Array.isArray(currentValue)) {
-          currentValue = currentValue[0];
-        }
-        value = String(currentValue);
-        if (typeof currentValue === "number") {
-          value = value.replace(".", ",");
-        }
-      }
-      line.push(value);
-    });
-    lines.push(line);
-  });
-  lines = lines.map((line) => {
-    return line.join(";");
-  });
-  return lines;
-}
-function getLayerSimpleConfig(layerData) {
-  if ("heatmap" in layerData) {
-    return {
-      type: "heatmap",
-      title: layerData.options.layerTitle,
-      colorField: layerData.options.colorTitle
-    };
-  }
-  if ("polygonmap" in layerData) {
-    const properties = layerData.polygonmap.polygons.features[0]?.properties.data?.map(
-      (d) => d.text.split(":")[0]?.trim()
-    );
-    const data = isEmpty(properties) ? void 0 : [
-      [...properties].join(";"),
-      ...layerData.polygonmap.polygons.features.map(
-        (d) => d.properties.data?.map((d2) => d2.text.split(":")[1]?.trim()).join(";")
-      )
-    ];
-    return {
-      type: "polygons",
-      title: layerData.options.layerTitle,
-      colorField: layerData.options.colorTitle,
-      data
-    };
-  }
-  if ("collection" in layerData) {
-    const items = layerData.collection.children ?? [];
-    if (isEmpty(items)) {
-      return {};
-    }
-    const layerType = items[0].feature.geometry.type;
-    const properties = items[0].feature.properties.data?.map(
-      (d) => d.text.split(":")[0]?.trim()
-    );
-    const data = isEmpty(properties) ? void 0 : [
-      [...properties].join(";"),
-      ...items.map(
-        (d) => d.feature.properties.data?.map((d2) => d2.text.split(":")[1]?.trim() ?? "").join(";")
-      )
-    ];
-    return {
-      type: layerType,
-      title: layerData.options.layerTitle,
-      colorField: layerData.options.colorTitle,
-      sizeField: layerData.options.sizeTitle,
-      data
-    };
-  }
-  if ("clusterer" in layerData) {
-    const properties = layerData.clusterer[0]?.feature.properties.data?.map(
-      (d) => d.text.split(":")[0]?.trim()
-    );
-    const data = isEmpty(properties) ? void 0 : [
-      [...properties].join(";"),
-      ...layerData.clusterer.map(
-        (d) => d.feature.properties.data?.map((d2) => d2.text.split(":")[1]?.trim() ?? "").join(";")
-      )
-    ];
-    return {
-      type: "points",
-      title: layerData.options.layerTitle,
-      colorField: layerData.options.colorTitle,
-      sizeField: layerData.options.sizeTitle,
-      data
-    };
-  }
-  return {};
-}
-function getMapSimpleConfig({ widgetData }) {
-  if (!widgetData) {
-    return {};
-  }
-  const layers = widgetData.data ?? [];
-  return {
-    type: widgetData.type,
-    layers: layers.map((d) => getLayerSimpleConfig(d)),
-    bounds: get(widgetData, "libraryConfig.state.bounds")
-  };
-}
-const COMPONENT_CLASSNAME = "dl-widget";
-const X_CSRF_TOKEN_HEADER = "X-CSRF-Token";
-const DATALENS_DEBUG_MODE_KEY = "datalens-debug-mode";
-const DRAGGABLE_HANDLE_CLASS_NAME = "dl-draggable-handle-element";
-const ALLOWED_ERRORS = [
-  ERROR_CODE.NO_DATA,
-  ERROR_CODE.TOO_MANY_LINES,
-  ERROR_CODE.UI_SANDBOX_EXECUTION_TIMEOUT
-];
-const getUniqDatasetsFields = (datasets) => {
-  datasets?.forEach((dataset) => {
-    if (!dataset.fieldsList) {
-      return;
-    }
-    const guids = {};
-    const newFieldList = [];
-    dataset.fieldsList.forEach((fieldItem) => {
-      if (!(fieldItem.guid in guids)) {
-        guids[fieldItem.guid] = "";
-        newFieldList.push(fieldItem);
-      }
-    });
-    dataset.fieldsList = newFieldList;
-  });
-  return datasets;
-};
-const getChartSimpleLoadedData = ({
-  widget,
-  loadedData
-}) => {
-  const convertedToTableData = convertChartToTable({
-    widget,
-    widgetData: loadedData
-  });
-  let queries;
-  if (loadedData && "sources" in loadedData) {
-    const sources = loadedData.sources ?? {};
-    const sourceValues = Object.values(sources);
-    queries = sourceValues.map((source) => {
-      return "info" in source ? source?.info : "";
-    });
-  }
-  let data = convertedToTableData;
-  if (isEmpty(convertedToTableData)) {
-    switch (loadedData?.type) {
-      case "metric":
-      case "metric2":
-      case "markup":
-      case "markdown": {
-        data = loadedData?.data;
-        break;
-      }
-      case "ymap": {
-        data = getMapSimpleConfig({
-          widgetData: loadedData
-        });
-        break;
-      }
-      default: {
-        data = loadedData;
-        break;
-      }
-    }
-  }
-  return { queries, data };
-};
-const getWidgetMeta = ({
-  tabs,
-  id,
-  loadData,
-  savedData,
-  error,
-  widgetDataRef
-}) => {
-  return tabs.map((tabWidget) => {
-    let loadedData = null;
-    if (loadData?.entryId === tabWidget.chartId) {
-      loadedData = loadData;
-    } else if (savedData?.entryId === tabWidget.chartId) {
-      loadedData = savedData;
-    }
-    const loadDataError = loadData?.data?.error;
-    const errorCode = error?.code;
-    const loadedWithError = Boolean(
-      (loadDataError || error) && (typeof errorCode !== "string" || !ALLOWED_ERRORS.includes(errorCode))
-    );
-    const metaInfo = {
-      layoutId: id,
-      chartId: tabWidget.chartId,
-      widgetId: tabWidget.id,
-      title: tabWidget.title,
-      label: loadedData?.key && Utils.getEntryNameFromKey(loadedData?.key || "") || "",
-      params: tabWidget.params,
-      enableFiltering: tabWidget.enableActionParams || false,
-      loaded: Boolean(loadedData),
-      entryId: tabWidget.chartId,
-      usedParams: loadedData?.usedParams ? Object.keys(loadedData?.usedParams || {}) || null : null,
-      datasets: getUniqDatasetsFields(loadedData?.datasets || loadedData?.extra?.datasets) || null,
-      datasetId: loadedData?.sources?.fields?.datasetId || loadedData?.extra?.datasets?.[0]?.id || "",
-      type: loadedData?.type || null,
-      visualizationType: loadedData?.libraryConfig?.chart?.type || null,
-      loadError: loadedWithError,
-      isWizard: Boolean(loadedData?.isNewWizard || loadedData?.isOldWizard),
-      isEditor: Boolean(loadedData?.isEditor),
-      isQL: Boolean(loadedData?.isQL),
-      getSimpleLoadedData: () => {
-        return getChartSimpleLoadedData({
-          widget: widgetDataRef?.current,
-          loadedData
-        });
-      }
-    };
-    return metaInfo;
-  });
-};
-const getWidgetSelectorMeta = ({
-  id,
-  chartId,
-  loadedData,
-  error,
-  widgetParamsDefaults,
-  data
-}) => {
-  const loadedWithError = Boolean(
-    loadedData?.data?.error || error
-  );
-  let title = "";
-  if (isExternalControl(data)) {
-    title = data.title;
-  }
-  const metaInfo = {
-    layoutId: id,
-    chartId,
-    widgetId: id,
-    title,
-    label: loadedData?.key && Utils.getEntryNameFromKey(loadedData?.key || "") || "",
-    params: loadedData?.params || {},
-    widgetParams: widgetParamsDefaults || {},
-    enableFiltering: false,
-    loaded: Boolean(loadedData),
-    entryId: chartId,
-    usedParams: loadedData?.usedParams ? Object.keys(loadedData?.usedParams || {}) || null : null,
-    datasets: loadedData?.datasets || null,
-    datasetId: loadedData?.sources?.fields?.datasetId || "",
-    type: loadedData?.type || null,
-    visualizationType: null,
-    loadError: loadedWithError,
-    getSimpleLoadedData: () => loadedData
-  };
-  return metaInfo;
-};
-const getPreparedConstants = (props) => {
-  const {
-    loadedData,
-    hideTitle,
-    widgetId,
-    history,
-    isLoading,
-    error,
-    isReloadWithNoVeil,
-    noVeil,
-    noLoader,
-    isSilentReload,
-    disableChartLoader,
-    needWaitForDSFields
-  } = props;
-  const widgetType = loadedData?.type;
-  let isFullscreen = false;
-  let noControls = false;
-  if (history) {
-    const searchParams = new URLSearchParams(history.location.search);
-    isFullscreen = widgetId === searchParams.get(FOCUSED_WIDGET_PARAM_NAME) && DL.IS_MOBILE;
-    noControls = isTrueArg(searchParams.get(URL_OPTIONS.NO_CONTROLS));
-  }
-  const isFirstLoadOrAfterError = loadedData === null;
-  const showLoader = Boolean(isLoading || needWaitForDSFields) && !disableChartLoader && (!isSilentReload && !noLoader || isFirstLoadOrAfterError);
-  const mods = {
-    "no-tabs": !isFullscreen && hideTitle,
-    fullscreen: isFullscreen,
-    "no-controls": noControls,
-    [String(widgetType)]: Boolean(widgetType),
-    "default-mobile": DL.IS_MOBILE && !isFullscreen
-  };
-  const hasVeil = Boolean(loadedData && !error && !noVeil && !isReloadWithNoVeil);
-  const noOverlay = !DL.IS_MOBILE || !loadedData || error || isWidgetTypeDoNotNeedOverlay(widgetType || "");
-  const showOverlayWithControlsOnEdit = !noOverlay && !isFullscreen;
-  return {
-    mods,
-    widgetBodyClassName: DL.IS_MOBILE ? "dl-chartkit-body-mix" : void 0,
-    hasHiddenClassMod: Boolean(isLoading && error),
-    veil: hasVeil,
-    showLoader,
-    isFullscreen,
-    widgetType,
-    showOverlayWithControlsOnEdit,
-    noControls
-  };
-};
-const removeEmptyNDatasetFieldsProperties = (obj, removeFieldsList) => {
-  const checkRemoveList = Boolean(removeFieldsList?.length);
-  return Object.entries(obj).reduce((result, [key, value]) => {
-    if (value !== null && value !== void 0) {
-      if (checkRemoveList) {
-        {
-          result[key] = value;
-        }
-      } else {
-        result[key] = value;
-      }
-    }
-    return result;
-  }, {});
-};
-const pushStats = (data, scope, chartsDataProvider2) => {
-  if (isEnabledFeature(Feature.EnableDashChartStat)) {
-    chartsDataProvider2.pushStats?.(data, {
-      groupId: DL.REQUEST_ID,
-      scope
-    });
-  }
-};
-const getTabIndex = (tabs, tabId) => {
-  if (!tabs) {
-    return 0;
-  }
-  const index = tabId ? tabs.findIndex(({ id }) => id === tabId) : tabs.findIndex(({ isDefault }) => isDefault);
-  return index === -1 ? 0 : index;
-};
-const isWidgetTypeWithAutoHeight = (widgetType) => {
-  return widgetType === DASH_WIDGET_TYPES.TABLE || widgetType === DASH_WIDGET_TYPES.MARKDOWN || widgetType === DASH_WIDGET_TYPES.METRIC || widgetType === DASH_WIDGET_TYPES.METRIC2 || widgetType === DASH_WIDGET_TYPES.MARKUP;
-};
-const updateImmediateLayout = ({
-  type,
-  autoHeight,
-  widgetId,
-  rootNode,
-  gridLayout,
-  layout,
-  cb
-}) => {
-  if (!type) {
-    return;
-  }
-  const newAutoHeight = isWidgetTypeWithAutoHeight(type) ? autoHeight : false;
-  adjustWidgetLayout({
-    widgetId,
-    needSetDefault: !newAutoHeight,
-    rootNode,
-    gridLayout,
-    layout,
-    cb
-  });
-};
-const isAllParamsEmpty = (params) => {
-  const res = Object.values(params || {}).every((item) => {
-    if (Array.isArray(item)) {
-      return isEmpty(item.filter((val) => !isEmpty(String(val).trim())));
-    } else {
-      return isEmpty(String(item).trim());
-    }
-  });
-  return Boolean(res);
-};
-const SNAPTER_DESIRED_CLASS = "chart-preview";
-const CHART_RELOAD_EVENT = "chartReload";
-const b$7 = block("chart-info");
-const MarkdownContent = (props) => {
-  const { value, onRender } = props;
-  const { markdown, isLoading } = useMarkdown({ value });
-  React__default.useEffect(() => {
-    if (!isLoading) {
-      onRender();
-    }
-  }, [isLoading, onRender]);
-  return /* @__PURE__ */ jsx(React__default.Fragment, { children: markdown });
-};
-const ChartInfoIcon = (props) => {
-  const { msg } = props;
-  const [isLoaded, setLoaded] = React__default.useState(false);
-  const content = DL.ENDPOINTS.safeChartInfoLink ? `${msg}
-[see](${DL.ENDPOINTS.safeChartInfoLink})` : msg;
-  return /* @__PURE__ */ jsx(
-    Popover,
-    {
-      content: /* @__PURE__ */ jsx(MarkdownContent, { value: content, onRender: () => setLoaded(true) }),
-      open: isLoaded,
-      className: b$7("tooltip", { hidden: !isLoaded }),
-      children: /* @__PURE__ */ jsx(Icon, { size: 20, data: ShieldExclamation, className: b$7("icon") })
-    },
-    String(isLoaded)
-  );
-};
-const iconClearActionParams = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20width='14'%20height='16'%20fill='none'%20viewBox='0%200%2014%2016'%3e%3cpath%20fill='currentColor'%20fill-opacity='1'%20fill-rule='evenodd'%20d='M10.055%207.602%208.31%2010.16a.354.354%200%200%200-.061.2v2.39c0%201.5-1.25%202.5-2.75%202.5s-1.75-1-1.75-1v-3.89a.354.354%200%200%200-.061-.2L.562%205.577A3.242%203.242%200%200%201%200%203.75c0-2%202.686-3%206-3%20.461%200%20.91.02%201.341.059a2.24%202.24%200%200%200-.323%201.478A13.777%2013.777%200%200%200%206%202.25c-1.538%200-2.799.237-3.615.613-.814.375-.885.713-.885.887%200%20.175.071.513.885.888.816.376%202.077.612%203.615.612.355%200%20.695-.012%201.018-.036a2.24%202.24%200%200%200%20.323%201.478c-.43.04-.88.058-1.341.058-1.114%200-2.158-.113-3.052-.339l1.98%202.904c.21.308.322.672.322%201.045v3.37c.06.011.141.02.25.02.422%200%20.749-.14.95-.316a.86.86%200%200%200%20.3-.683V10.36c0-.373.112-.737.322-1.045l1.214-1.78a2.241%202.241%200%200%200%201.77.067Zm-4.936%206.085c-.01-.006-.013-.01-.013-.01s.005.002.013.01Z'%20clip-rule='evenodd'/%3e%3cpath%20fill='currentColor'%20fill-opacity='1'%20fill-rule='evenodd'%20d='M9.278.97a.75.75%200%200%200-1.06%201.06l1.72%201.72-1.72%201.72a.75.75%200%200%200%201.06%201.062L11%204.812l1.72%201.72A.75.75%200%201%200%2013.78%205.47l-1.72-1.72%201.72-1.721A.75.75%200%200%200%2012.72.97l-1.721%201.72L9.279.97Z'%20clip-rule='evenodd'/%3e%3c/svg%3e";
-const b$6 = block("dl-widget");
-function hasNoControlsParamVal(val) {
-  const paramVal = Array.isArray(val) ? val[0] : val;
-  return ["1", "true", 1, true].includes(paramVal);
-}
-const Header = (props) => {
-  const {
-    isMenuAvailable,
-    chartsInsightsData,
-    menuType,
-    customMenuOptions,
-    menuChartkitConfig,
-    error,
-    dataProps,
-    requestId,
-    loadedData,
-    chartRevIdRef,
-    widgetDataRef,
-    widgetRenderTimeRef,
-    yandexMapAPIWaiting,
-    dataProvider,
-    onChange,
-    isWidgetMenuDataChanged,
-    onExportLoading,
-    onFullscreenClick,
-    enableActionParams,
-    enableAssistant,
-    showActionParamsFilter,
-    onFiltersClear,
-    extraOptions,
-    reload
-  } = props;
-  const dispatch = useDispatch();
-  const [commentsLength, setCommentsLength] = React__default.useState(null);
-  const isEditAvaible = useSelector(selectWorkbookEditPermission);
-  const handleCommentsChanged = React__default.useCallback(
-    (length) => {
-      setCommentsLength(length);
-      reload?.();
-    },
-    [reload]
-  );
-  const hideChartComments = Boolean(loadedData?.config?.hideComments);
-  const hideControlsByParam = hasNoControlsParamVal(
-    get(dataProps?.params || "", URL_OPTIONS.NO_CONTROLS)
-  );
-  const canBeShownMenu = isMenuAvailable && widgetDataRef && !hideControlsByParam;
-  const configMenu = menuType ? getChartkitMenu({
-    type: menuType,
-    customOptions: customMenuOptions,
-    config: menuChartkitConfig?.config,
-    chartsDataProvider: menuChartkitConfig?.chartsDataProvider || dataProvider,
-    onExportLoading,
-    onFullscreenClick,
-    isEditAvaible,
-    extraOptions: { ...extraOptions, enableActionParams, enableAssistant },
-    widgetConfig: loadedData?.widgetConfig,
-    dispatch
-  }) : settings_default.menu;
-  const { ChartActionPanelButton } = registry.chart.components.getAll();
-  const chartData = dataProps ? dataProps : {};
-  const safeChartWarning = get(loadedData, "safeChartInfo");
-  const showFiltersClear = showActionParamsFilter && onFiltersClear;
-  return /* @__PURE__ */ jsxs("div", { className: b$6("chart-header"), children: [
-    safeChartWarning && /* @__PURE__ */ jsx(ChartInfoIcon, { msg: safeChartWarning }),
-    /* @__PURE__ */ jsx(
-      ChartActionPanelButton,
-      {
-        menuType,
-        loadedData,
-        widgetDataRef,
-        chartData
-      }
-    ),
-    /* @__PURE__ */ jsxs("div", { className: b$6("controls-corner-wrapper"), children: [
-      canBeShownMenu && /* @__PURE__ */ jsx(
-        MenuWithErrorBoundary,
-        {
-          commentsLength,
-          hideChartComments,
-          configMenu,
-          widgetDataRef,
-          loadedData,
-          chartRevIdRef,
-          error,
-          propsData: chartData,
-          requestId,
-          widgetRenderTimeRef,
-          yandexMapAPIWaiting,
-          callbackOnCommentsChanged: handleCommentsChanged,
-          hideComments,
-          drawComments,
-          onChange,
-          isWidgetMenuDataChanged,
-          chartsDataProvider: dataProvider
-        }
-      ),
-      showFiltersClear && props.canBeDisplayedFilters && /* @__PURE__ */ jsx("div", { className: b$6("icons"), children: /* @__PURE__ */ jsx("div", { className: b$6("filters-controls"), children: /* @__PURE__ */ jsx(
-        Button,
-        {
-          qa: ControlQA.filtersClear,
-          onClick: onFiltersClear,
-          className: b$6("filter-button"),
-          view: "flat-secondary",
-          children: /* @__PURE__ */ jsx(
-            Icon,
-            {
-              data: iconClearActionParams,
-              size: 16,
-              className: b$6("icon-filter-clear")
-            }
-          )
-        }
-      ) }) }),
-      chartsInsightsData && /* @__PURE__ */ jsx(
-        ChartsInsights,
-        {
-          items: chartsInsightsData.items,
-          messagesByLocator: chartsInsightsData.messagesByLocator,
-          locators: chartsInsightsData.locators
-        }
-      )
-    ] })
-  ] });
-};
-const Chart$1 = (props) => {
-  if (props.error) {
-    return /* @__PURE__ */ jsx(
-      ChartkitError,
-      {
-        error: props.error,
-        onRetry: props.onRetry,
-        requestId: props.requestId,
-        noControls: props.noControls
-      }
-    );
-  }
-  const preparedData = typeof props.transformLoadedData === "function" ? props.transformLoadedData(props.loadedData) : props.loadedData;
-  if (props.loadedData && props.loadedData.type !== "control") {
-    return /* @__PURE__ */ jsx(
-      ChartKitAdapter,
-      {
-        ref: props.forwardedRef,
-        loadedData: preparedData,
-        splitTooltip: props.splitTooltip,
-        nonBodyScroll: props.nonBodyScroll,
-        isMobile: settings_default.isMobile,
-        lang: settings_default.lang,
-        onLoad: props.onLoad,
-        onError: props.onError,
-        onChange: props.onChange,
-        onRender: props.onRender,
-        onChartLoad: props.onChartLoad,
-        renderPluginLoader: props.renderPluginLoader,
-        requestId: props.requestId,
-        noControls: props.noControls,
-        onRetry: props.onRetry,
-        paneSplitOrientation: props.paneSplitOrientation,
-        widgetDashState: props.widgetDashState,
-        rootNodeRef: props.rootNodeRef,
-        backgroundColor: props.backgroundColor,
-        runActivity: props.runActivity
-      }
-    );
-  }
-  return null;
-};
-const DatalensChartkitContent = React__default.memo(Chart$1);
-const b$5 = block("dl-widget");
-const emptyLoaderComponent = () => /* @__PURE__ */ jsx(
-  Loader,
-  {
-    visible: true,
-    compact: false,
-    size: "s",
-    veil: false,
-    delay: 1e3,
-    classNameMod: b$5("chartkit-inner-loader")
-  }
-);
-const Control$1 = ExtensionsManager.getWithWrapper(
-  "control"
-);
-const Content = (props) => {
-  const {
-    hasHiddenClassMod,
-    showLoader,
-    veil,
-    loaderDelay,
-    widgetBodyClassName,
-    forwardedRef,
-    noControls,
-    nonBodyScroll,
-    transformLoadedData,
-    splitTooltip,
-    compactLoader,
-    chartId,
-    chartRevIdRef,
-    requestId,
-    error,
-    onRender,
-    onChange,
-    onError,
-    onRetry,
-    loadedData,
-    getControls,
-    drillDownFilters,
-    drillDownLevel,
-    widgetType,
-    menuType,
-    customMenuOptions,
-    menuChartkitConfig,
-    dataProps,
-    yandexMapAPIWaiting,
-    widgetDataRef,
-    widgetRenderTimeRef,
-    onFullscreenClick,
-    showOverlayWithControlsOnEdit,
-    dataProvider,
-    isWidgetMenuDataChanged,
-    renderPluginLoader,
-    enableActionParams,
-    enableAssistant,
-    paneSplitOrientation,
-    widgetDashState,
-    rootNodeRef,
-    runActivity,
-    backgroundColor,
-    showActionParamsFilter,
-    onFiltersClear,
-    reload
-  } = props;
-  const [isExportLoading, setIsExportLoading] = React__default.useState(false);
-  const dispatch = useDispatch();
-  const handleExportLoading = React__default.useCallback(
-    (isLoading) => {
-      setIsExportLoading(isLoading);
-      dispatch(setSkipReload(isLoading));
-    },
-    [dispatch]
-  );
-  const id = React__default.useMemo(() => getRandomCKId(), []);
-  const hasControl = Boolean(loadedData?.controls?.controls?.length);
-  const showControls = !noControls && loadedData?.controls && ExtensionsManager.has("control");
-  const drillDownData = loadedData?.config?.drillDown;
-  const chartsInsightsData = loadedData?.chartsInsightsData;
-  const sideMarkdownData = loadedData?.sideMarkdown || "";
-  const showChartOverlay = Boolean(showOverlayWithControlsOnEdit && onFullscreenClick);
-  const initialParams = {
-    params: props.initialParams || {}
-  };
-  const showContentLoader = showLoader || isExportLoading;
-  const showLoaderVeil = veil && !isExportLoading;
-  const isFirstLoadingFloat = loadedData === null;
-  const [hasDummy, setHasDummy] = React__default.useState(DL.IS_MOBILE && !splitTooltip);
-  const chartInnerLoaderComponent = isFirstLoadingFloat ? emptyLoaderComponent : renderPluginLoader;
-  const handleRender = React__default.useCallback(
-    (args) => {
-      setHasDummy(false);
-      onRender?.(args);
-    },
-    [onRender]
-  );
-  return /* @__PURE__ */ jsxs("div", { className: b$5("container", { [String(widgetType)]: Boolean(widgetType) }), children: [
-    props.needRenderContentControls && /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
-      /* @__PURE__ */ jsx(
-        Loader,
-        {
-          visible: showContentLoader,
-          compact: compactLoader,
-          veil: showLoaderVeil,
-          delay: loaderDelay
-        }
-      ),
-      /* @__PURE__ */ jsx(
-        Header,
-        {
-          dataProvider,
-          chartsInsightsData,
-          menuType,
-          customMenuOptions,
-          menuChartkitConfig,
-          isMenuAvailable: !noControls,
-          error,
-          dataProps,
-          requestId,
-          loadedData,
-          chartRevIdRef,
-          widgetDataRef,
-          widgetRenderTimeRef,
-          yandexMapAPIWaiting,
-          onChange,
-          isWidgetMenuDataChanged,
-          onExportLoading: handleExportLoading,
-          enableActionParams,
-          enableAssistant,
-          onFullscreenClick,
-          showActionParamsFilter,
-          onFiltersClear,
-          reload
-        }
-      )
-    ] }),
-    /* @__PURE__ */ jsxs(
-      "div",
-      {
-        className: b$5(
-          "body",
-          { hidden: hasHiddenClassMod, [String(widgetType)]: Boolean(widgetType) },
-          widgetBodyClassName
-        ),
-        "data-qa": chartId ? `chartkit-body-entry-${chartId}` : null,
-        children: [
-          Boolean(showControls && hasControl && getControls) && /* @__PURE__ */ jsx(
-            Control$1,
-            {
-              id,
-              data: loadedData,
-              onLoad: onRender,
-              onError,
-              onChange,
-              getControls,
-              nonBodyScroll,
-              initialParams,
-              runActivity
-            }
-          ),
-          Boolean(drillDownData) && /* @__PURE__ */ jsx(
-            Drill,
-            {
-              onChange,
-              breadcrumbs: drillDownData.breadcrumbs,
-              filters: drillDownFilters,
-              level: drillDownLevel
-            }
-          ),
-          Boolean(sideMarkdownData) && /* @__PURE__ */ jsx(SideMarkdown, { data: sideMarkdownData }),
-          hasDummy && /* @__PURE__ */ jsx("div", { className: b$5("mobile-loading-dummy") }),
-          /* @__PURE__ */ jsx(
-            DatalensChartkitContent,
-            {
-              noControls,
-              transformLoadedData,
-              splitTooltip,
-              nonBodyScroll,
-              requestId,
-              error,
-              onLoad: handleRender,
-              onChange,
-              onError,
-              onRetry,
-              loadedData,
-              forwardedRef,
-              renderPluginLoader: chartInnerLoaderComponent,
-              paneSplitOrientation,
-              widgetDashState,
-              rootNodeRef,
-              backgroundColor,
-              runActivity
-            }
-          ),
-          showChartOverlay && /* @__PURE__ */ jsx(
-            "div",
-            {
-              className: b$5("overlay"),
-              onClick: onFullscreenClick,
-              "data-qa": "chart-widget-overlay"
-            }
-          )
-        ]
-      }
-    )
-  ] });
-};
-const WIDGET_CHART_SET_LOADING = /* @__PURE__ */ Symbol("widgetChart/SET_LOADING");
-const WIDGET_CHART_SET_DATA_PARAMS = /* @__PURE__ */ Symbol("widgetChart/SET_DATA_PARAMS");
-const WIDGET_CHART_UPDATE_DATA_PARAMS = /* @__PURE__ */ Symbol("widgetChart/UPDATE_DATA_PARAMS");
-const WIDGET_CHART_SET_LOADED_DATA = /* @__PURE__ */ Symbol("widgetChart/SET_LOADED_DATA");
-const WIDGET_CHART_SET_WIDGET_DATA = /* @__PURE__ */ Symbol("widgetChart/SET_WIDGET_DATA");
-const WIDGET_CHART_RESET_CHANGED_PARAMS = /* @__PURE__ */ Symbol("widgetChart/RESET_WIDGET_CHANGED_DATA");
-const WIDGET_CHART_SET_LOAD_SETTINGS = /* @__PURE__ */ Symbol("widgetChart/CHARTKIT_SET_LOAD_SETTINGS");
-const WIDGET_CHART_SET_WIDGET_ERROR = /* @__PURE__ */ Symbol("widgetChart/SET_WIDGET_ERROR");
-const getInitialState = () => {
-  return {
-    isLoading: false,
-    isSilentReload: false,
-    isReloadWithNoVeil: false,
-    loadedData: null,
-    widget: null,
-    yandexMapAPIWaiting: null,
-    error: null,
-    changedParams: null,
-    usedParams: null
-  };
-};
-const reducer = (state, action) => {
-  switch (action.type) {
-    case WIDGET_CHART_SET_LOAD_SETTINGS:
-    case WIDGET_CHART_SET_WIDGET_ERROR:
-    case WIDGET_CHART_SET_WIDGET_DATA: {
-      return {
-        ...state,
-        ...action.payload
-      };
-    }
-    case WIDGET_CHART_SET_LOADING: {
-      return {
-        ...state,
-        isLoading: action.payload
-      };
-    }
-    case WIDGET_CHART_SET_LOADED_DATA:
-      return {
-        ...state,
-        loadedData: action.payload,
-        isLoading: false,
-        isSilentReload: false,
-        isReloadWithNoVeil: false,
-        error: null,
-        usedParams: action.payload?.usedParams || null
-      };
-    case WIDGET_CHART_SET_DATA_PARAMS: {
-      return {
-        ...state,
-        changedParams: {
-          ...action.payload
-        }
-      };
-    }
-    case WIDGET_CHART_UPDATE_DATA_PARAMS: {
-      return {
-        ...state,
-        changedParams: {
-          ...state.changedParams,
-          ...action.payload
-        }
-      };
-    }
-    case WIDGET_CHART_RESET_CHANGED_PARAMS: {
-      const newData = action.payload || {};
-      return {
-        ...state,
-        changedParams: newData
-      };
-    }
-    default: {
-      return state;
-    }
-  }
-};
-function cleanUpConflictingParameters(args) {
-  const { prev, current } = args;
-  const tableRowSortKey = "_sortRowMeta";
-  if (prev && current && tableRowSortKey in current) {
-    if (!isEqual(omit(prev, tableRowSortKey), omit(current, tableRowSortKey))) {
-      delete current[tableRowSortKey];
-    }
-  }
-}
-const useChartActivities = ({
-  requestId,
-  requestHeadersGetter,
-  dataProvider,
-  initialData,
-  onChange,
-  onActivityComplete
-}) => {
-  const dispatch = useDispatch();
-  const handleActivityCompleteSuccess = React__default.useCallback(
-    async (responseData) => {
-      switch (responseData?.data?.action) {
-        case "toast": {
-          const { title = "", type, content = "" } = responseData.data;
-          const renderMarkdown = await getRenderMarkdownFn();
-          dispatch(
-            showToast({
-              title,
-              type,
-              content: /* @__PURE__ */ jsx(
-                YfmWrapper,
-                {
-                  setByInnerHtml: true,
-                  content: renderMarkdown(content)
-                }
-              )
-            })
-          );
-          break;
-        }
-        case "popup": {
-          const { title = "", content = "" } = responseData.data;
-          const renderMarkdown = await getRenderMarkdownFn();
-          dispatch(
-            openDialog({
-              id: DIALOG_DEFAULT,
-              props: {
-                open: true,
-                onApply: () => {
-                  dispatch(closeDialog());
-                },
-                onCancel: () => dispatch(closeDialog()),
-                caption: title,
-                message: /* @__PURE__ */ jsx(
-                  YfmWrapper,
-                  {
-                    setByInnerHtml: true,
-                    content: renderMarkdown(content)
-                  }
-                )
-              }
-            })
-          );
-          break;
-        }
-        case "setParams": {
-          if (onChange) {
-            onChange(
-              { type: "PARAMS_CHANGED", data: { params: responseData.data.params } },
-              { forceUpdate: true },
-              true
-            );
-          }
-          break;
-        }
-      }
-    },
-    [dispatch, onChange]
-  );
-  const inProgressRef = React__default.useRef(false);
-  const runActivity = React__default.useCallback(
-    async ({ params }) => {
-      if (inProgressRef.current) {
-        return null;
-      }
-      inProgressRef.current = true;
-      let responseData;
-      try {
-        responseData = await dataProvider.makeActivityRequest({
-          props: { ...initialData, params },
-          requestId,
-          ...requestHeadersGetter ? { contextHeaders: requestHeadersGetter() } : {}
-        });
-      } catch (e) {
-        responseData = { error: e };
-      }
-      if (responseData?.error) {
-        switch (responseData.settings?.logError) {
-          case "toast": {
-            dispatch(
-              showToast({
-                type: "danger",
-                title: i18n("chartkit.data-provider", "error-execution"),
-                error: ChartsDataProvider.formatError(
-                  responseData.error,
-                  false
-                )
-              })
-            );
-            break;
-          }
-          case "ignore": {
-            break;
-          }
-          default: {
-            console.error(responseData.error);
-            break;
-          }
-        }
-      } else if (responseData) {
-        handleActivityCompleteSuccess(responseData);
-      }
-      onActivityComplete?.({ responseData });
-      inProgressRef.current = false;
-      return responseData;
-    },
-    [
-      dataProvider,
-      dispatch,
-      handleActivityCompleteSuccess,
-      initialData,
-      onActivityComplete,
-      requestHeadersGetter,
-      requestId
-    ]
-  );
-  return {
-    runActivity
-  };
-};
-const THROTTLE_VISIBLE_DELAY = 100;
-const LOADING_VISIBLE_OFFSET = 300;
-const LOADING_INTERSECTION_RATIO = 0.05;
-class Observer {
-  constructor() {
-    this.callbacksMap = /* @__PURE__ */ new Map();
-    this.changesQueue = null;
-    this.intersectionObserver = null;
-    this.intersectionFlushQueue = throttle(() => {
-      if (this.changesQueue === null) {
-        return;
-      }
-      const { callbacksMap, changesQueue } = this;
-      const changes = changesQueue;
-      this.changesQueue = null;
-      changes.forEach((isVisible, el) => {
-        callbacksMap.get(el)?.(isVisible);
-      });
-      changes.clear();
-    }, THROTTLE_VISIBLE_DELAY);
-    this.intersectionHandler = (entries) => {
-      this.changesQueue = this.changesQueue || /* @__PURE__ */ new Map();
-      const hasChanges = entries.reduce((memo, e) => {
-        const target = e.target;
-        const isVisible = e.intersectionRatio > 0;
-        const currentVisibility = this.changesQueue?.get(target);
-        if (currentVisibility !== isVisible) {
-          this.changesQueue?.set(target, isVisible);
-          return true;
-        }
-        return memo;
-      }, false);
-      if (hasChanges) {
-        this.intersectionFlushQueue();
-      }
-    };
-  }
-  getIntersectionObserver() {
-    if (this.intersectionObserver === null) {
-      this.intersectionObserver = new IntersectionObserver(this.intersectionHandler, {
-        rootMargin: `${LOADING_VISIBLE_OFFSET}px`,
-        threshold: [0, LOADING_INTERSECTION_RATIO]
-      });
-    }
-    return this.intersectionObserver;
-  }
-  cleanIntersectionObserver() {
-    if (this.callbacksMap.size === 0) {
-      this.getIntersectionObserver().disconnect();
-      this.intersectionObserver = null;
-    }
-  }
-  subscribe(element, callback) {
-    this.getIntersectionObserver().observe(element);
-    this.callbacksMap.set(element, callback);
-    this.triggerSync(element, callback);
-  }
-  unsubscribe(element) {
-    if (this.intersectionObserver === null) {
-      return;
-    }
-    this.intersectionObserver.unobserve(element);
-    this.callbacksMap.delete(element);
-    this.changesQueue?.delete(element);
-    this.cleanIntersectionObserver();
-  }
-  /**
-   * Sync call for priority loading to work as intended
-   * cause all selectors are added to load queue while first render
-   * if we will delegate this to IntersectionObserver init call micro-task
-   * we will be already late by the time when loading will be already started
-   */
-  triggerSync(element, callback) {
-    const { top, height } = element.getBoundingClientRect();
-    const bottom = top + height;
-    const isVisible = top < window.innerHeight + LOADING_VISIBLE_OFFSET && bottom >= 0;
-    callback(isVisible);
-  }
-}
-const observer = new Observer();
-const useIntersectionObserver = ({
-  nodeRef,
-  callback,
-  enable
-}) => {
-  React__default.useEffect(() => {
-    const element = nodeRef.current;
-    if (!element) {
-      return;
-    }
-    if (enable) {
-      observer.subscribe(element, callback);
-    } else {
-      observer.unsubscribe(element);
-    }
-    return () => {
-      observer.unsubscribe(element);
-    };
-  }, [nodeRef, callback, enable]);
-};
-const useMemoCallback = (callback, deps) => {
-  const callbackRef = React__default.useRef(callback);
-  callbackRef.current = callback;
-  return React__default.useMemo(() => {
-    return ((...args) => callbackRef.current(...args));
-  }, deps);
-};
-const EXCLUDE_CHART_WITH_AXIS_FOR_MENU_RERENDER = ["map"];
-const loadingStateReducer = (state, newState) => {
-  const hasChanges = Object.entries(newState).find(
-    ([key, value]) => state[key] !== value
-  );
-  if (hasChanges) {
-    return { ...state, ...newState };
-  }
-  return state;
-};
-const useLoadingChart = (props) => {
-  const {
-    dataProvider,
-    requestHeadersGetter,
-    initialData,
-    requestId,
-    requestCancellationRef,
-    rootNodeRef,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    hasChartTabChanged,
-    hasChangedActionParams,
-    onChartRender,
-    onChartLoad,
-    chartKitRef,
-    resolveMetaDataRef,
-    resolveWidgetDataRef,
-    usedParamsRef,
-    innerParamsRef,
-    widgetDataRef,
-    widgetRenderTimeRef,
-    handleChangeCallback,
-    ignoreUsedParams,
-    clearedOuterParams,
-    onInnerParamsChanged,
-    enableActionParams,
-    widgetType,
-    autoupdateInterval,
-    isPageHidden,
-    forceShowSafeChart,
-    onBeforeChartLoad,
-    onActivityComplete
-  } = props;
-  const [{ isInit, canBeLoaded }, setLoadingState] = React__default.useReducer(loadingStateReducer, {
-    isInit: false,
-    canBeLoaded: false
-  });
-  const isMounted = useMountedState([]);
-  const setIsInit = React__default.useCallback((value) => setLoadingState({ isInit: value }), []);
-  const setCanBeLoaded = React__default.useCallback(
-    (value) => setLoadingState({ canBeLoaded: value }),
-    []
-  );
-  const [yandexMapAPIWaiting, setYandexMapAPIWaiting] = React__default.useState();
-  const [widgetMenuData, setWidgetMenuData] = React__default.useState(null);
-  const [isWidgetMenuDataChanged, setIsWidgetMenuDataChanged] = React__default.useState(false);
-  const prevWidgetMenuData = usePrevious(widgetMenuData);
-  const prevInnerParamsRefCurrent = usePrevious(innerParamsRef?.current);
-  const [
-    {
-      changedParams,
-      usedParams,
-      isLoading,
-      isSilentReload,
-      isReloadWithNoVeil,
-      loadedData,
-      error
-    },
-    dispatch
-  ] = React__default.useReducer(reducer, getInitialState());
-  const [renderedCallbackCalledOnce, setRenderedCallbackCalledOnce] = React__default.useState(false);
-  const [changedInnerFlag, setChangedInnerFlag] = React__default.useState(false);
-  const autoupdateDataRef = React__default.useRef({
-    isPageHidden: false,
-    reloadTimeout: void 0,
-    lastReloadAt: void 0
-  });
-  autoupdateDataRef.current.isPageHidden = isPageHidden;
-  const currentChangeParamsRef = React__default.useRef(null);
-  const loadedDrillDownLevel = React__default.useMemo(() => {
-    let level = Array.isArray(loadedData?.params.drillDownLevel) ? loadedData?.params.drillDownLevel[0] : loadedData?.params.drillDownLevel;
-    level = String(level)?.trim() || "0";
-    return Number(level) || 0;
-  }, [loadedData?.params.drillDownLevel]);
-  const [currentDrillDownLevel, setCurrentDrillDownLevel] = React__default.useState(loadedDrillDownLevel);
-  const drillDownFilters = React__default.useMemo(
-    () => loadedData?.params.drillDownFilters || [],
-    [loadedData?.params.drillDownFilters]
-  );
-  const requestDataProps = React__default.useMemo(() => {
-    let res = { ...initialData };
-    let params = { ...initialData.params };
-    if (!ignoreUsedParams && usedParams) {
-      params = pick(initialData.params || {}, Object.keys(usedParams));
-    }
-    let localParams = hasChartTabChanged ? {} : changedParams || {};
-    if (hasChangedActionParams && changedParams) {
-      const localActionParams = pickActionParamsFromParams(changedParams, true);
-      const newLocalActionParams = {};
-      for (const [key, val] of Object.entries(localActionParams)) {
-        if (key in params) {
-          newLocalActionParams[key] = val;
-        }
-      }
-      const localOnlyParams = pickExceptActionParamsFromParams(changedParams);
-      localParams = { ...localOnlyParams, ...newLocalActionParams };
-    }
-    currentChangeParamsRef.current = localParams;
-    if (hasChangedOuterProps || hasChangedOuterParams) {
-      const filteredLocalParams = clearedOuterParams?.length ? omit(localParams, clearedOuterParams) : localParams;
-      const newParams = hasChangedOuterParams && isEmpty(params) ? {
-        ...params
-      } : {
-        ...filteredLocalParams,
-        ...params
-      };
-      res = {
-        ...res,
-        params: newParams
-      };
-    } else {
-      res = {
-        ...res,
-        params: {
-          ...params,
-          ...localParams
-        }
-      };
-    }
-    if (forceShowSafeChart) {
-      res = {
-        ...res,
-        params: {
-          ...res.params,
-          [SHARED_URL_OPTIONS.SAFE_CHART]: "1"
-        }
-      };
-    }
-    return res;
-  }, [
-    ignoreUsedParams,
-    hasChangedActionParams,
-    changedParams,
-    initialData,
-    usedParams,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    hasChartTabChanged,
-    clearedOuterParams,
-    currentChangeParamsRef,
-    forceShowSafeChart
-  ]);
-  const handleError = React__default.useCallback(
-    ({ error: errorMsg }) => {
-      const errorRequestId = "debug" in errorMsg && errorMsg.debug?.requestId || loadedData?.requestId;
-      const traceId = "debug" in errorMsg && errorMsg.debug?.traceId || loadedData?.traceId;
-      const formattedError = formatError({
-        error: errorMsg,
-        requestId: errorRequestId,
-        traceId
-      });
-      dispatch({
-        type: WIDGET_CHART_SET_WIDGET_ERROR,
-        payload: {
-          isLoading: false,
-          isSilentReload: false,
-          isReloadWithNoVeil: false,
-          error: formattedError
-        }
-      });
-      onChartRender?.(
-        {
-          status: "error",
-          data: {
-            error: errorMsg,
-            loadedData
-          }
-        },
-        dataProvider
-      );
-    },
-    [loadedData, dispatch, onChartRender, dataProvider]
-  );
-  const cancelAllLoadingRequests = React__default.useCallback(
-    (isComponentMounted) => {
-      for (const [key, requestStatusData] of Object.entries(
-        requestCancellationRef.current || {}
-      )) {
-        const needToCancelReq = requestStatusData.status === "loading" || requestStatusData.status === "unset" && requestId !== key || !isComponentMounted;
-        if (needToCancelReq && requestStatusData.requestCancellation) {
-          requestStatusData.status = "canceled";
-          dataProvider.cancelRequests(requestStatusData.requestCancellation);
-        }
-      }
-    },
-    [requestCancellationRef, dataProvider, requestId]
-  );
-  const loadChartData = React__default.useCallback(async () => {
-    if (!requestDataProps) {
-      return;
-    }
-    cleanUpConflictingParameters({
-      prev: prevInnerParamsRefCurrent,
-      current: requestDataProps.params
-    });
-    if (changedInnerFlag) {
-      setChangedInnerFlag(false);
-    }
-    dispatch({ type: WIDGET_CHART_SET_LOADING, payload: true });
-    try {
-      if (innerParamsRef) {
-        innerParamsRef.current = requestDataProps.params;
-      }
-      if (hasChangedOuterParams) {
-        dispatch({
-          type: clearedOuterParams?.length ? WIDGET_CHART_SET_DATA_PARAMS : WIDGET_CHART_UPDATE_DATA_PARAMS,
-          payload: requestDataProps.params
-        });
-      }
-      if (hasChartTabChanged || hasChangedActionParams) {
-        const newChangedParams = hasChangedActionParams && currentChangeParamsRef?.current || null;
-        dispatch({ type: WIDGET_CHART_RESET_CHANGED_PARAMS, payload: newChangedParams });
-      }
-      let widgetConfig;
-      if (enableActionParams) {
-        widgetConfig = {
-          actionParams: {
-            enable: true
-          }
-        };
-      }
-      const getWidgetProps = widgetType === DashTabItemControlSourceType.External ? {
-        ...requestDataProps,
-        widgetType: DashTabItemControlSourceType.External,
-        widgetConfig
-      } : { ...requestDataProps, widgetConfig };
-      const getWidget = dataProvider.getWidget.bind(dataProvider);
-      const loadedWidgetData = await getWidget({
-        props: getWidgetProps,
-        requestId,
-        requestCancellation: requestCancellationRef.current[requestId]?.requestCancellation || dataProvider.getRequestCancellation(),
-        ...requestHeadersGetter ? { contextHeaders: requestHeadersGetter() } : {},
-        widgetElement: rootNodeRef.current ?? void 0
-      });
-      const isCanceled = requestCancellationRef.current?.[requestId]?.status === "canceled";
-      if (isCanceled || loadedWidgetData === void 0 || !rootNodeRef.current) {
-        if (requestCancellationRef.current[requestId]) {
-          delete requestCancellationRef.current[requestId];
-        }
-        return;
-      }
-      if (requestCancellationRef.current?.[requestId]?.status) {
-        requestCancellationRef.current[requestId].status = "loaded";
-      }
-      if (usedParamsRef) {
-        usedParamsRef.current = loadedWidgetData?.usedParams || null;
-      }
-      if (changedInnerFlag) {
-        setChangedInnerFlag(false);
-      }
-      resolveMetaDataRef?.current?.(
-        resolveWidgetDataRef?.current?.(
-          loadedWidgetData
-        )
-      );
-      await onBeforeChartLoad?.();
-      onChartLoad?.({
-        status: "success",
-        data: {
-          loadedData: loadedWidgetData
-        }
-      });
-      dispatch({ type: WIDGET_CHART_SET_LOADED_DATA, payload: loadedWidgetData });
-    } catch (err) {
-      if (requestCancellationRef.current?.[requestId]?.status) {
-        requestCancellationRef.current[requestId].status = "error";
-      }
-      handleError({
-        error: DatalensChartkitCustomError.wrap(err, {
-          code: err.code || ERROR_CODE.DATA_PROVIDER_ERROR
-        })
-      });
-      onChartLoad?.({
-        status: "error",
-        data: {
-          error: DatalensChartkitCustomError.wrap(err, {
-            code: err.code || ERROR_CODE.DATA_PROVIDER_ERROR
-          })
-        }
-      });
-      resolveMetaDataRef?.current?.(resolveWidgetDataRef?.current?.(null));
-    }
-  }, [
-    requestHeadersGetter,
-    dispatch,
-    changedInnerFlag,
-    usedParamsRef,
-    innerParamsRef,
-    handleError,
-    requestDataProps,
-    requestId,
-    requestCancellationRef,
-    dataProvider,
-    resolveMetaDataRef,
-    resolveWidgetDataRef,
-    hasChangedOuterParams,
-    onChartLoad,
-    clearedOuterParams,
-    widgetType,
-    rootNodeRef,
-    enableActionParams
-  ]);
-  const reloadChart = React__default.useCallback(() => {
-    const autoupdateIntervalMs = Number(autoupdateInterval) * 1e3;
-    if (autoupdateIntervalMs) {
-      const timeSinceLastReload = (/* @__PURE__ */ new Date()).getTime() - (autoupdateDataRef.current.lastReloadAt || 0);
-      const reloadIntervalRemains = autoupdateIntervalMs - timeSinceLastReload;
-      if ((!autoupdateDataRef.current.isPageHidden || isEmbeddedMode()) && reloadIntervalRemains <= 0 && autoupdateDataRef.current.reloadTimeout) {
-        autoupdateDataRef.current.lastReloadAt = (/* @__PURE__ */ new Date()).getTime();
-        loadChartData();
-      }
-      autoupdateDataRef.current.reloadTimeout = setTimeout(
-        () => reloadChart(),
-        autoupdateIntervalMs
-      );
-    }
-  }, [loadChartData, autoupdateInterval]);
-  React__default.useEffect(() => {
-    clearTimeout(autoupdateDataRef.current.reloadTimeout);
-    if (!isPageHidden) {
-      reloadChart();
-    }
-  }, [isPageHidden, autoupdateInterval]);
-  const intersectionChange = React__default.useCallback(
-    (isVisible) => {
-      if (isVisible) {
-        setLoadingState({
-          canBeLoaded: true,
-          isInit: true
-        });
-        loadChartData();
-      }
-    },
-    [loadChartData]
-  );
-  useIntersectionObserver({
-    nodeRef: rootNodeRef,
-    callback: intersectionChange,
-    enable: !isInit && !canBeLoaded
-  });
-  React__default.useEffect(() => {
-    return () => {
-      const isComponentMounted = isMounted();
-      if (!isComponentMounted) {
-        cancelAllLoadingRequests(isComponentMounted);
-      }
-    };
-  }, [isMounted, cancelAllLoadingRequests]);
-  React__default.useEffect(() => {
-    if (!canBeLoaded || isInit) {
-      return;
-    }
-    setIsInit(true);
-    loadChartData();
-  }, [canBeLoaded, isInit, loadChartData]);
-  React__default.useEffect(() => {
-    const changedOuter = hasChangedOuterProps || hasChangedOuterParams || hasChartTabChanged;
-    const hasChanged = changedOuter || changedInnerFlag;
-    if (!hasChanged || !isInit) {
-      return;
-    }
-    cancelAllLoadingRequests(true);
-    dispatch({ type: WIDGET_CHART_SET_LOADING, payload: true });
-    requestCancellationRef.current[requestId] = {
-      status: "loading",
-      requestCancellation: requestCancellationRef.current[requestId]?.requestCancellation || dataProvider.getRequestCancellation()
-    };
-    loadChartData();
-  }, [
-    requestId,
-    requestCancellationRef,
-    cancelAllLoadingRequests,
-    loadChartData,
-    changedInnerFlag,
-    isInit,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    hasChartTabChanged,
-    dispatch
-  ]);
-  React__default.useEffect(() => {
-    const isChanged = !isEqual(widgetMenuData, prevWidgetMenuData);
-    setIsWidgetMenuDataChanged(isChanged);
-  }, [widgetMenuData, prevWidgetMenuData]);
-  const handleRenderChart = React__default.useCallback(
-    (renderedData) => {
-      if (!loadedData) {
-        return;
-      }
-      if (!renderedData) {
-        if (!renderedCallbackCalledOnce) {
-          onChartRender?.(
-            {
-              status: null
-            },
-            dataProvider
-          );
-          setRenderedCallbackCalledOnce(true);
-        }
-        return;
-      }
-      if (widgetDataRef) {
-        widgetDataRef.current = renderedData.widget || null;
-      }
-      const needSetMenuConfigData = renderedData.widget && widgetDataRef?.current && "xAxis" in renderedData.widget && !EXCLUDE_CHART_WITH_AXIS_FOR_MENU_RERENDER.includes(loadedData.type);
-      if (needSetMenuConfigData) {
-        setWidgetMenuData({
-          xAxis: (widgetDataRef?.current).xAxis || null
-        });
-      }
-      if (widgetRenderTimeRef) {
-        widgetRenderTimeRef.current = renderedData.widgetRendering || null;
-      }
-      setYandexMapAPIWaiting(renderedData?.yandexMapAPIWaiting);
-      if (typeof loadedData?.uiSandboxOptions?.totalTimeLimit !== "undefined") {
-        delete loadedData.uiSandboxOptions.totalTimeLimit;
-      }
-      onChartRender?.(
-        {
-          status: "success",
-          data: {
-            widgetData: renderedData.widget || null,
-            loadedData
-            // for ChartStats
-          }
-        },
-        dataProvider
-      );
-    },
-    [
-      loadedData,
-      widgetRenderTimeRef,
-      widgetDataRef,
-      renderedCallbackCalledOnce,
-      onChartRender,
-      dataProvider
-    ]
-  );
-  const handleChartkitReflow = React__default.useCallback(() => {
-    chartKitRef.current?.reflow?.();
-  }, [chartKitRef]);
-  const setLoadingProps = React__default.useCallback(
-    (arg) => {
-      if (!arg) {
-        return;
-      }
-      dispatch({
-        type: WIDGET_CHART_SET_LOAD_SETTINGS,
-        payload: {
-          isSilentReload: Boolean(arg.silentLoading),
-          isReloadWithNoVeil: Boolean(arg.noVeil)
-        }
-      });
-    },
-    [dispatch]
-  );
-  const loadChart = React__default.useCallback(() => {
-    if (!canBeLoaded || !isInit) {
-      return;
-    }
-    loadChartData();
-  }, [canBeLoaded, isInit, loadChartData]);
-  const loadControls = React__default.useCallback(
-    async (params) => {
-      if (!dataProvider.getControls && typeof dataProvider.getControls !== "function") {
-        console.warn("ChartKit: getControls called but not defined in dataProvider");
-        return null;
-      }
-      try {
-        const loadedControlsData = await dataProvider.getControls({
-          props: { ...initialData, params },
-          requestId,
-          requestCancellation: requestCancellationRef.current[requestId]?.requestCancellation || dataProvider.getRequestCancellation(),
-          ...requestHeadersGetter ? { contextHeaders: requestHeadersGetter() } : {}
-        });
-        if (!rootNodeRef.current) {
-          return null;
-        }
-        return loadedControlsData;
-      } catch (err) {
-        handleError({
-          error: DatalensChartkitCustomError.wrap(err, {
-            code: err.code || ERROR_CODE.DATA_PROVIDER_ERROR
-          })
-        });
-      }
-      return null;
-    },
-    [
-      dataProvider,
-      initialData,
-      requestId,
-      requestCancellationRef,
-      rootNodeRef,
-      handleError,
-      requestHeadersGetter
-    ]
-  );
-  const handleChange = useMemoCallback(
-    // eslint-disable-next-line complexity
-    (changedData, _state, callExternalOnChange, callChangeByClick) => {
-      if (changedData.type === "PARAMS_CHANGED") {
-        let newParams = null;
-        let additionalParams = {};
-        if ("params" in changedData.data) {
-          const newDrillDownLevel = Number(changedData.data.params.drillDownLevel);
-          if (!isNaN(newDrillDownLevel) && (currentDrillDownLevel || newDrillDownLevel) && currentDrillDownLevel !== newDrillDownLevel) {
-            additionalParams = {
-              _page: String(START_PAGE)
-            };
-          }
-          const mapParam = (val) => {
-            if (typeof val === "string") {
-              return unescape(val);
-            }
-            return val;
-          };
-          newParams = Object.entries(changedData.data.params).reduce(
-            (acc, [key, value]) => {
-              acc[key] = Array.isArray(value) ? value.map(mapParam) : mapParam(value);
-              return acc;
-            },
-            {}
-          );
-          newParams = { ...newParams, ...additionalParams };
-          if (!enableActionParams) {
-            newParams = pickExceptActionParamsFromParams(newParams);
-          }
-        }
-        if (newParams?.drillDownLevel !== void 0) {
-          setCurrentDrillDownLevel(
-            Number(newParams?.drillDownLevel || 0)
-          );
-        }
-        const needUpdateChartParams = !isEqual(initialData.params, newParams) || callChangeByClick;
-        const needClearParamsQueue = !isAllParamsEmpty(
-          pickActionParamsFromParams(prevInnerParamsRefCurrent || void 0)
-        ) && isAllParamsEmpty(newParams);
-        if (newParams && needUpdateChartParams) {
-          const actionName = isEmpty(newParams) && callChangeByClick ? WIDGET_CHART_RESET_CHANGED_PARAMS : WIDGET_CHART_UPDATE_DATA_PARAMS;
-          dispatch({
-            type: actionName,
-            payload: newParams
-          });
-          setChangedInnerFlag(true);
-        }
-        if (newParams && typeof onInnerParamsChanged === "function") {
-          onInnerParamsChanged(newParams);
-        }
-        if (callExternalOnChange && typeof handleChangeCallback === "function" && newParams) {
-          const options = needClearParamsQueue ? {
-            action: "removeItem"
-          } : void 0;
-          handleChangeCallback({
-            type: "PARAMS_CHANGED",
-            data: {
-              params: newParams
-            },
-            options
-          });
-        }
-      } else if (callExternalOnChange && typeof handleChangeCallback === "function") {
-        const res = { ...changedData };
-        if (enableActionParams && "params" in res.data) {
-          res.data.params = pickExceptActionParamsFromParams(
-            res.data.params
-          );
-        }
-        handleChangeCallback(res);
-      }
-    },
-    []
-  );
-  const handleRetry = React__default.useCallback(
-    (data) => {
-      if (data) {
-        if ("params" in data) {
-          handleChange({ type: "PARAMS_CHANGED", data }, { forceUpdate: true }, false);
-        }
-      } else {
-        loadChartData();
-      }
-    },
-    [loadChartData, handleChange]
-  );
-  const { runActivity } = useChartActivities({
-    requestId,
-    requestHeadersGetter,
-    dataProvider,
-    initialData,
-    onChange: handleChange,
-    onActivityComplete
-  });
-  return {
-    loadedData,
-    isLoading,
-    isSilentReload,
-    isReloadWithNoVeil,
-    error,
-    handleRenderChart,
-    handleChartkitReflow,
-    handleChange,
-    handleError,
-    handleRetry,
-    loadChartData: loadChart,
-    reloadChart: loadChartData,
-    setLoadingProps,
-    loadControls,
-    drillDownFilters,
-    drillDownLevel: currentDrillDownLevel,
-    setCurrentDrillDownLevel,
-    yandexMapAPIWaiting,
-    setCanBeLoaded,
-    isInit,
-    dataProps: requestDataProps,
-    isWidgetMenuDataChanged,
-    runActivity
-  };
-};
-const b$4 = block(COMPONENT_CLASSNAME);
-const influencingProps$2 = [
-  "dataProvider",
-  "id",
-  "source",
-  "params",
-  "config"
-];
-const Chart = (props) => {
-  const {
-    dataProvider,
-    forwardedRef,
-    noLoader,
-    noVeil,
-    noControls,
-    nonBodyScroll,
-    transformLoadedData,
-    splitTooltip,
-    compactLoader,
-    loaderDelay,
-    config,
-    id: chartId,
-    revId: chartRevId,
-    menuType,
-    customMenuOptions,
-    onChartRender,
-    onChartLoad,
-    ignoreUsedParams,
-    onInnerParamsChanged,
-    disableChartLoader,
-    actionParamsEnabled,
-    enableAssistant,
-    isPageHidden,
-    autoupdateInterval,
-    workbookId,
-    forceShowSafeChart,
-    paneSplitOrientation,
-    widgetDashState,
-    onBeforeChartLoad,
-    onActivityComplete
-  } = props;
-  const innerParamsRef = React__default.useRef(null);
-  const prevInnerParams = usePrevious(innerParamsRef?.current);
-  const chartkitParams = React__default.useMemo(
-    () => removeEmptyNDatasetFieldsProperties({ ...props.params }),
-    [props.params]
-  );
-  const initialData = React__default.useMemo(
-    () => getDataProviderData({
-      id: chartId,
-      config,
-      params: chartkitParams,
-      workbookId
-    }),
-    [config, chartId, chartkitParams, workbookId]
-  );
-  const savedForFetchProps = React__default.useMemo(() => pick(props, influencingProps$2), [props]);
-  const prevSavedProps = usePrevious(savedForFetchProps);
-  const hasChangedOuterProps = !prevSavedProps || !isEqual(omit(prevSavedProps, ["params"]), omit(pick(props, influencingProps$2), ["params"]));
-  const hasChangedOuterParams = !prevSavedProps || !isEqual(prevSavedProps.params, props.params);
-  const clearedOuterParams = prevSavedProps ? Object.keys(omit(prevSavedProps.params, Object.keys(props?.params || {}))) : [];
-  const hasChangedInnerParamsFromInside = React__default.useMemo(() => {
-    return prevInnerParams && !isEqual(innerParamsRef?.current, prevInnerParams);
-  }, [prevInnerParams, innerParamsRef?.current]);
-  const requestId = React__default.useMemo(
-    () => settings_default.requestIdGenerator(DL.REQUEST_ID_PREFIX),
-    [hasChangedOuterProps, hasChangedOuterParams, hasChangedInnerParamsFromInside]
-  );
-  const rootNodeRef = React__default.useRef(props.rootNodeRef?.current || null);
-  const chartRevIdRef = React__default.useRef();
-  const widgetDataRef = React__default.useRef(null);
-  const widgetRenderTimeRef = React__default.useRef(null);
-  const chartKitRef = React__default.useRef(null);
-  const [initialParams, setInitialParams] = React__default.useState({});
-  const renderPluginLoader = React__default.useMemo(() => {
-    return disableChartLoader ? () => null : void 0;
-  }, [disableChartLoader]);
-  const requestCancellationRef = React__default.useRef({
-    [requestId]: {
-      requestCancellation: dataProvider.getRequestCancellation(),
-      status: "unset"
-    }
-  });
-  React__default.useEffect(() => {
-    if (chartRevIdRef.current !== chartRevId) {
-      chartRevIdRef.current = chartRevId;
-    }
-  }, [chartRevId]);
-  React__default.useEffect(() => {
-    requestCancellationRef.current[requestId] = {
-      requestCancellation: dataProvider.getRequestCancellation(),
-      status: "unset"
-    };
-  }, [requestCancellationRef, dataProvider, requestId]);
-  const {
-    loadedData,
-    isLoading,
-    isSilentReload,
-    isReloadWithNoVeil,
-    error,
-    handleRenderChart,
-    handleChange,
-    handleRetry,
-    handleError,
-    loadControls,
-    drillDownFilters,
-    drillDownLevel,
-    yandexMapAPIWaiting,
-    dataProps,
-    isWidgetMenuDataChanged,
-    reloadChart,
-    runActivity,
-    handleChartkitReflow
-  } = useLoadingChart({
-    chartKitRef,
-    dataProvider,
-    initialData,
-    requestId,
-    requestCancellationRef,
-    innerParamsRef,
-    rootNodeRef,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    widgetDataRef,
-    widgetRenderTimeRef,
-    onChartRender,
-    onChartLoad,
-    ignoreUsedParams,
-    clearedOuterParams,
-    onInnerParamsChanged,
-    enableActionParams: actionParamsEnabled,
-    isPageHidden,
-    autoupdateInterval,
-    forceShowSafeChart,
-    onBeforeChartLoad,
-    onActivityComplete
-  });
-  React__default.useEffect(() => {
-    setInitialParams(loadedData?.defaultParams || {});
-  }, [loadedData?.defaultParams]);
-  const { mods, widgetBodyClassName, hasHiddenClassMod, veil, showLoader, widgetType } = React__default.useMemo(
-    () => getPreparedConstants({
-      isLoading,
-      error,
-      loadedData,
-      isReloadWithNoVeil,
-      noLoader,
-      noVeil,
-      isSilentReload,
-      disableChartLoader
-    }),
-    [
-      isLoading,
-      error,
-      loadedData,
-      isReloadWithNoVeil,
-      noLoader,
-      noVeil,
-      compactLoader,
-      loaderDelay,
-      disableChartLoader
-    ]
-  );
-  React__default.useEffect(() => {
-    if (isEmbeddedMode()) {
-      const handleMessageEvent = (event) => {
-        if (event.data.type === CHART_RELOAD_EVENT) {
-          reloadChart();
-        }
-      };
-      window.addEventListener("message", handleMessageEvent);
-      return () => {
-        window.removeEventListener("message", handleMessageEvent);
-      };
-    }
-    return void 0;
-  }, [reloadChart]);
-  React__default.useImperativeHandle(
-    forwardedRef,
-    () => ({
-      reflow: handleChartkitReflow,
-      reload: () => {
-        reloadChart();
-      }
-    }),
-    [handleChartkitReflow, reloadChart]
-  );
-  return /* @__PURE__ */ jsxs("div", { ref: rootNodeRef, className: b$4(mods), "data-qa": ChartkitMenuDialogsQA.chartWidget, children: [
-    /* @__PURE__ */ jsx(DebugInfoTool, { data: [{ label: "chartId", value: chartId || "" }] }),
-    /* @__PURE__ */ jsx(
-      Content,
-      {
-        initialParams,
-        dataProps,
-        dataProvider,
-        showLoader,
-        compactLoader,
-        veil,
-        loaderDelay,
-        widgetBodyClassName,
-        hasHiddenClassMod,
-        chartId,
-        chartRevIdRef,
-        noControls,
-        transformLoadedData,
-        splitTooltip,
-        nonBodyScroll,
-        requestId,
-        error,
-        onRender: handleRenderChart,
-        onChange: handleChange,
-        onRetry: handleRetry,
-        onError: handleError,
-        loadedData,
-        forwardedRef: chartKitRef,
-        getControls: loadControls,
-        runActivity,
-        drillDownFilters,
-        drillDownLevel,
-        widgetType,
-        menuType,
-        customMenuOptions,
-        widgetDataRef,
-        widgetRenderTimeRef,
-        yandexMapAPIWaiting,
-        isWidgetMenuDataChanged,
-        renderPluginLoader,
-        paneSplitOrientation,
-        widgetDashState,
-        rootNodeRef,
-        needRenderContentControls: true,
-        enableAssistant,
-        reload: reloadChart
-      }
-    )
-  ] });
-};
-function useChangedValue(value, comparator = isEqual) {
-  const prevValueRef = React__default.useRef(value);
-  const isChanged = !comparator(prevValueRef.current, value);
-  if (isChanged) {
-    prevValueRef.current = value;
-  }
-  return isChanged;
-}
-const useResizeObserver = (options) => {
-  const { rootNodeRef, enable, onResize } = options;
-  const isInitResizeCall = React__default.useRef(true);
-  const resizeObserver = React__default.useRef(null);
-  const previousWidthValue = React__default.useRef(null);
-  const onResizeRef = React__default.useRef(onResize);
-  onResizeRef.current = onResize;
-  const resizeObserverHandler = React__default.useCallback(() => {
-    if (!rootNodeRef.current) {
-      return;
-    }
-    const { clientWidth } = rootNodeRef.current;
-    if (isInitResizeCall.current) {
-      isInitResizeCall.current = false;
-      previousWidthValue.current = clientWidth;
-      return;
-    }
-    if (previousWidthValue.current === clientWidth) {
-      return;
-    }
-    previousWidthValue.current = clientWidth;
-    onResizeRef.current();
-  }, [onResizeRef, previousWidthValue, rootNodeRef, isInitResizeCall]);
-  const disconnectResizeObserver = React__default.useCallback(() => {
-    if (resizeObserver.current) {
-      resizeObserver.current.disconnect();
-      resizeObserver.current = null;
-      isInitResizeCall.current = true;
-      previousWidthValue.current = null;
-    }
-  }, [resizeObserver, isInitResizeCall]);
-  React__default.useLayoutEffect(() => {
-    if (!rootNodeRef.current) {
-      return;
-    }
-    if (!enable) {
-      disconnectResizeObserver();
-      return;
-    } else if (!resizeObserver.current) {
-      previousWidthValue.current = null;
-      resizeObserver.current = new ResizeObserver(resizeObserverHandler);
-      resizeObserver.current.observe(rootNodeRef.current);
-    }
-  }, [enable, rootNodeRef, resizeObserver, resizeObserverHandler, disconnectResizeObserver]);
-  React__default.useEffect(() => {
-    return () => {
-      if (resizeObserver.current) {
-        resizeObserver.current.disconnect();
-        resizeObserver.current = null;
-      }
-    };
-  }, [resizeObserver]);
-};
-const WIDGET_RESIZE_DEBOUNCE_TIMEOUT$1 = 600;
-const useLoadingChartSelector = (props) => {
-  const {
-    dataProvider,
-    initialData,
-    requestId,
-    requestCancellationRef,
-    rootNodeRef,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    adjustWidgetLayout: adjustWidgetLayout$1,
-    widgetId,
-    gridLayout,
-    layout,
-    noVeil,
-    noLoader,
-    onStateAndParamsChange,
-    chartKitRef,
-    width,
-    height,
-    usedParamsRef,
-    innerParamsRef,
-    widgetDataRef,
-    usageType,
-    chartId,
-    widgetType,
-    settings,
-    data,
-    onActivityComplete,
-    updateTabsWithGlobalState
-  } = props;
-  const [isRendered, setIsRendered] = React__default.useState(false);
-  const resolveMetaDataRef = React__default.useRef();
-  const resolveWidgetDataRef = React__default.useRef();
-  const extDashkitContext = React__default.useContext(ExtendedDashKitContext);
-  const dataProviderContextGetter = extDashkitContext?.dataProviderContextGetter || void 0;
-  const history = useHistory();
-  const loadOnlyVisibleCharts = settings.loadOnlyVisibleCharts ?? true;
-  const handleUpdate = useBeforeLoad(props.onBeforeLoad);
-  const adjustLayout = React__default.useCallback(
-    (needSetDefault) => {
-      adjustWidgetLayout({
-        widgetId,
-        needSetDefault,
-        rootNode: rootNodeRef,
-        gridLayout,
-        layout,
-        cb: adjustWidgetLayout$1
-      });
-    },
-    [widgetId, rootNodeRef, gridLayout, adjustWidgetLayout$1]
-  );
-  const handleRenderChartWidget = React__default.useCallback(
-    (renderedData) => {
-      if (renderedData?.status === "success") {
-        pushStats(renderedData, "dash", dataProvider);
-      }
-      const newAutoHeight = Boolean(props.data.autoHeight);
-      adjustLayout(!newAutoHeight);
-      setIsRendered(true);
-      if (isReadyToReflowRef.current && handleUpdate) {
-        requestAnimationFrame(() => handleUpdate());
-      }
-    },
-    [adjustLayout, dataProvider, props.data.autoHeight]
-  );
-  const handleChangeCallback = React__default.useCallback(
-    (changedProps) => {
-      if (changedProps.type === "PARAMS_CHANGED") {
-        updateTabsWithGlobalState?.({
-          params: changedProps.data.params,
-          selectorItem: {
-            type: DashTabItemType.Control,
-            data,
-            id: widgetId
-          },
-          appliedSelectorsIds: [widgetId]
-        });
-        onStateAndParamsChange({ params: changedProps.data.params || {} });
-      }
-    },
-    [data, onStateAndParamsChange, updateTabsWithGlobalState, widgetId]
-  );
-  const handleChartLoad = React__default.useCallback(
-    ({ data: data2, status }) => {
-      if (status === "error" || data2?.loadedData?.data?.error) {
-        adjustLayout(false);
-        return;
-      }
-      const newAutoHeight = Boolean(props.data.autoHeight);
-      adjustLayout(!newAutoHeight);
-    },
-    [adjustLayout, props.data.autoHeight]
-  );
-  const requestHeadersGetter = React__default.useMemo(() => {
-    return dataProviderContextGetter?.bind(void 0, widgetId);
-  }, [widgetId, dataProviderContextGetter]);
-  const {
-    loadedData,
-    isLoading,
-    isSilentReload,
-    isReloadWithNoVeil,
-    error,
-    handleChartkitReflow,
-    handleChange,
-    handleError,
-    handleRetry,
-    loadChartData,
-    setLoadingProps,
-    setCanBeLoaded,
-    isInit,
-    dataProps,
-    handleRenderChart,
-    loadControls,
-    runActivity
-  } = useLoadingChart({
-    dataProvider,
-    requestHeadersGetter,
-    initialData,
-    requestId,
-    requestCancellationRef,
-    rootNodeRef,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    onChartLoad: handleChartLoad,
-    onChartRender: handleRenderChartWidget,
-    chartKitRef,
-    resolveMetaDataRef,
-    resolveWidgetDataRef,
-    usedParamsRef,
-    innerParamsRef,
-    handleChangeCallback,
-    widgetDataRef,
-    widgetType,
-    onActivityComplete
-  });
-  const {
-    mods,
-    widgetBodyClassName,
-    hasHiddenClassMod,
-    showLoader,
-    showOverlayWithControlsOnEdit
-  } = React__default.useMemo(
-    () => getPreparedConstants({
-      isLoading,
-      error,
-      loadedData,
-      isReloadWithNoVeil,
-      noLoader,
-      noVeil,
-      isSilentReload,
-      history,
-      widgetId
-    }),
-    [
-      isLoading,
-      error,
-      loadedData,
-      isReloadWithNoVeil,
-      noLoader,
-      noVeil,
-      isSilentReload,
-      history,
-      widgetId
-    ]
-  );
-  const widgetParamsDefaults = React__default.useMemo(() => {
-    const item = extDashkitContext?.config?.items.find(
-      ({ id }) => id === widgetId
-    );
-    return item?.defaults || {};
-  }, [extDashkitContext?.config, widgetId]);
-  const isReadyToReflowRef = React__default.useRef(false);
-  isReadyToReflowRef.current = isInit && !isLoading && isRendered;
-  const debouncedChartReflow = React__default.useCallback(
-    debounce(() => {
-      handleChartkitReflow();
-      if (isReadyToReflowRef.current && handleUpdate) {
-        requestAnimationFrame(() => handleUpdate());
-      }
-    }, WIDGET_RESIZE_DEBOUNCE_TIMEOUT$1),
-    [handleChartkitReflow]
-  );
-  const getCurrentWidgetResolvedMetaInfo = React__default.useCallback(
-    (loadData) => {
-      const meta = getWidgetSelectorMeta({
-        loadedData: loadData,
-        id: widgetId,
-        chartId,
-        error,
-        widgetParamsDefaults,
-        data
-      });
-      if (resolveMetaDataRef.current) {
-        resolveMetaDataRef.current(meta);
-      }
-    },
-    [
-      resolveMetaDataRef.current,
-      loadedData,
-      widgetId,
-      chartId,
-      error,
-      widgetParamsDefaults,
-      data
-    ]
-  );
-  const handleGetWidgetMeta = React__default.useCallback(
-    (argResolve) => {
-      resolveMetaDataRef.current = argResolve;
-      resolveWidgetDataRef.current = (resolvingData) => {
-        getCurrentWidgetResolvedMetaInfo(resolvingData);
-      };
-      if (!isInit) {
-        setCanBeLoaded(true);
-      }
-      if (!loadedData) {
-        if (error) {
-          resolveWidgetDataRef.current(null);
-        }
-        return;
-      }
-      resolveWidgetDataRef.current(loadedData);
-    },
-    [
-      error,
-      loadedData,
-      setCanBeLoaded,
-      isInit,
-      getCurrentWidgetResolvedMetaInfo,
-      resolveMetaDataRef,
-      resolveWidgetDataRef
-    ]
-  );
-  const isAutoHeightEnabled = Boolean(props.data.autoHeight) || Boolean(error);
-  const autoHeightEnabled = isInit && isAutoHeightEnabled;
-  const debounceResizeAdjustLayot = React__default.useCallback(
-    debounce(() => {
-      adjustLayout(!isAutoHeightEnabled);
-    }, WIDGET_RESIZE_DEBOUNCE_TIMEOUT$1),
-    [adjustLayout, isAutoHeightEnabled]
-  );
-  useResizeObserver({
-    onResize: debounceResizeAdjustLayot,
-    rootNodeRef,
-    enable: autoHeightEnabled
-  });
-  React__default.useEffect(() => {
-    debouncedChartReflow();
-  }, [width, height, debouncedChartReflow]);
-  const currentLayout = layout.find(({ i }) => i === widgetId);
-  React__default.useEffect(() => {
-    if (isInit && !isLoading && isRendered) {
-      handleUpdate?.();
-    }
-  }, [currentLayout?.x, currentLayout?.y, isLoading, isInit, isRendered, handleUpdate]);
-  React__default.useEffect(() => {
-    if (loadOnlyVisibleCharts === false) {
-      setCanBeLoaded(true);
-    }
-  }, [setCanBeLoaded, loadOnlyVisibleCharts]);
-  return {
-    loadedData,
-    isLoading,
-    isSilentReload,
-    isReloadWithNoVeil,
-    isAutoHeightEnabled,
-    error,
-    handleChartkitReflow,
-    handleChange,
-    handleError,
-    handleRetry,
-    handleUpdate: debounceResizeAdjustLayot,
-    handleGetWidgetMeta,
-    mods,
-    widgetBodyClassName,
-    hasHiddenClassMod,
-    showLoader,
-    loadChartData,
-    setLoadingProps,
-    showOverlayWithControlsOnEdit,
-    dataProps,
-    handleRenderChart,
-    getControls: loadControls,
-    runActivity
-  };
-};
-const b$3 = block(COMPONENT_CLASSNAME);
-const influencingProps$1 = [
-  "dataProvider",
-  "id",
-  "source",
-  "params",
-  "config"
-];
-const Control = ExtensionsManager.getWithWrapper(
-  "control"
-);
-const ChartSelector = (props) => {
-  const {
-    dataProvider,
-    forwardedRef,
-    nonBodyScroll,
-    id: chartId,
-    config,
-    widgetId,
-    workbookId
-  } = props;
-  const skipReload = useSelector(selectSkipReload);
-  const chartkitParams = React__default.useMemo(() => {
-    let res = removeEmptyNDatasetFieldsProperties(props.params);
-    res = pickExceptActionParamsFromParams(res);
-    return res;
-  }, [props.params]);
-  const prevCurrentDefaults = usePrevious(props.defaults);
-  const hasCurrentDefaultsChanged = prevCurrentDefaults && !isEqual(props.defaults, prevCurrentDefaults);
-  const initialData = React__default.useMemo(
-    () => getDataProviderData({
-      id: chartId,
-      config,
-      params: chartkitParams,
-      workbookId
-    }),
-    [chartId, chartkitParams, config, workbookId]
-  );
-  const usedParamsRef = React__default.useRef(null);
-  const innerParamsRef = React__default.useRef(null);
-  const hasInfluencingPropsChanged = useChangedValue(
-    omit(pick(props, influencingProps$1), "params")
-  );
-  const hasParamsChanged = useChangedValue(props.params);
-  const hasInnerParamsChanged = useChangedValue(innerParamsRef?.current);
-  const hasChartIdChanged = useChangedValue(chartId);
-  const hasChangedOuterProps = hasInfluencingPropsChanged || hasChartIdChanged;
-  const hasChangedOuterParams = React__default.useMemo(() => {
-    let changedParams = hasParamsChanged;
-    let isOuterAndInnerParamsEqual = false;
-    if (changedParams && innerParamsRef?.current) {
-      const innerFullParams = innerParamsRef?.current;
-      const outerFullParams = props.params;
-      isOuterAndInnerParamsEqual = isEqual(innerFullParams, outerFullParams);
-    }
-    if (isOuterAndInnerParamsEqual) {
-      changedParams = false;
-    }
-    return changedParams;
-  }, [hasParamsChanged, props.params, usedParamsRef, innerParamsRef]);
-  const requestId = React__default.useMemo(
-    () => settings_default.requestIdGenerator(DL.REQUEST_ID_PREFIX),
-    [hasChangedOuterParams, hasChangedOuterProps, hasInnerParamsChanged]
-  );
-  const requestCancellationRef = React__default.useRef({
-    [requestId]: {
-      requestCancellation: dataProvider.getRequestCancellation(),
-      status: "unset"
-    }
-  });
-  React__default.useEffect(() => {
-    requestCancellationRef.current[requestId] = {
-      requestCancellation: dataProvider.getRequestCancellation(),
-      status: "unset"
-    };
-  }, [requestCancellationRef, dataProvider, requestId]);
-  const rootNodeRef = React__default.useRef(null);
-  const chartKitRef = React__default.useRef();
-  const widgetDataRef = React__default.useRef(null);
-  const [initialParams, setInitialParams] = React__default.useState(
-    props.initialParams?.params || {}
-  );
-  const controlInitialParams = {
-    params: initialParams || {}
-  };
-  const widgetType = DashTabItemControlSourceType.External;
-  const {
-    loadedData,
-    error,
-    handleRenderChart,
-    mods,
-    widgetBodyClassName,
-    hasHiddenClassMod,
-    showLoader,
-    handleGetWidgetMeta,
-    handleChartkitReflow,
-    handleChange,
-    handleError,
-    handleRetry,
-    handleUpdate,
-    loadChartData,
-    setLoadingProps,
-    getControls,
-    isAutoHeightEnabled,
-    runActivity
-  } = useLoadingChartSelector({
-    ...props,
-    chartKitRef,
-    rootNodeRef,
-    initialData,
-    requestId,
-    requestCancellationRef,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    widgetId,
-    usedParamsRef,
-    innerParamsRef,
-    widgetDataRef,
-    chartId,
-    widgetType
-  });
-  const hasControl = Boolean(loadedData?.controls?.controls?.length);
-  React__default.useEffect(() => {
-    if (!hasCurrentDefaultsChanged && !loadedData) {
-      return;
-    }
-    setInitialParams({ ...loadedData?.defaultParams, ...props.defaults });
-  }, [hasCurrentDefaultsChanged, props.defaults, loadedData?.defaultParams]);
-  React__default.useImperativeHandle(
-    forwardedRef,
-    () => ({
-      props,
-      reflow: handleChartkitReflow,
-      reload: (arg) => {
-        if (skipReload) {
-          return;
-        }
-        setLoadingProps(arg);
-        loadChartData();
-      },
-      getMeta: () => new Promise((resolve) => handleGetWidgetMeta(resolve)),
-      getCurrentTabChartId: () => chartId || ""
-    }),
-    [
-      forwardedRef,
-      handleChartkitReflow,
-      handleGetWidgetMeta,
-      skipReload,
-      loadChartData,
-      setLoadingProps,
-      chartId,
-      loadedData
-      // loadedData in deps for meta actual data
-    ]
-  );
-  const hasError = Boolean(
-    error || loadedData?.data?.error
-  );
-  const isLoading = showLoader && !hasError;
-  const pulsate = isLoading && hasControl;
-  const showSpinner = isLoading && !hasControl;
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      ref: rootNodeRef,
-      className: `${b$3({
-        ...mods,
-        autoheight: isAutoHeightEnabled,
-        pulsate
-      })}`,
-      "data-qa": "chart-widget-selectors",
-      children: [
-        /* @__PURE__ */ jsx(
-          DebugInfoTool,
-          {
-            data: [
-              { label: "widgetId", value: widgetId },
-              { label: "chartId", value: chartId }
-            ]
-          }
-        ),
-        /* @__PURE__ */ jsxs("div", { className: b$3("container", { [String(widgetType)]: Boolean(widgetType) }), children: [
-          showSpinner && /* @__PURE__ */ jsx("div", { className: b$3("loader"), children: /* @__PURE__ */ jsx(Loader$1, { size: "s" }) }),
-          /* @__PURE__ */ jsxs(
-            "div",
-            {
-              className: b$3(
-                "body",
-                { hidden: hasHiddenClassMod, [String(widgetType)]: Boolean(widgetType) },
-                widgetBodyClassName
-              ),
-              "data-qa": chartId ? `chartkit-body-entry-${chartId}` : null,
-              children: [
-                Boolean(!hasError && hasControl && getControls) && /* @__PURE__ */ jsx(
-                  Control,
-                  {
-                    id: chartId,
-                    data: loadedData,
-                    onLoad: handleRenderChart,
-                    onError: handleError,
-                    onChange: handleChange,
-                    onUpdate: handleUpdate,
-                    getControls,
-                    nonBodyScroll,
-                    initialParams: controlInitialParams,
-                    runActivity
-                  }
-                ),
-                /* @__PURE__ */ jsx(
-                  DatalensChartkitContent,
-                  {
-                    nonBodyScroll,
-                    requestId,
-                    error,
-                    onLoad: handleRenderChart,
-                    onChange: handleChange,
-                    onError: handleError,
-                    onRetry: handleRetry,
-                    loadedData,
-                    forwardedRef,
-                    rootNodeRef
-                  }
-                )
-              ]
-            }
-          )
-        ] })
-      ]
-    }
-  );
-};
-const b$2 = block(COMPONENT_CLASSNAME);
-const WidgetFooter = (props) => {
-  const { isFullscreen, description, author, withPaddings, enableDescription, metaScripts } = props;
-  const enableDesc = enableDescription === void 0 ? Boolean(description) : enableDescription;
-  const showWidgetFooter = Boolean(!isFullscreen && (enableDesc || author));
-  return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
-    showWidgetFooter && /* @__PURE__ */ jsx("div", { className: b$2("description", { "with-paddings": Boolean(withPaddings) }), children: description && /* @__PURE__ */ jsx(
-      YfmWrapper,
-      {
-        content: description,
-        setByInnerHtml: true,
-        metaScripts
-      }
-    ) }),
-    author && author.text && /* @__PURE__ */ jsx("div", { className: b$2("author", { "with-paddings": Boolean(withPaddings) }), children: author.link ? /* @__PURE__ */ jsx(Link, { target: "_blank", view: "normal", href: author.link, children: author.text }) : author.text })
-  ] });
-};
-const b$1 = block("widget-header");
-const WidgetHeader = (props) => {
-  const {
-    widgetId,
-    isFullscreen,
-    onFullscreenClick,
-    editMode,
-    hideTitle,
-    tabsItems,
-    currentTab,
-    onSelectTab,
-    hideDebugTool,
-    showActionParamsFilter,
-    onFiltersClear,
-    title,
-    noControls,
-    setIsExportLoading,
-    extraMod
-  } = props;
-  const headerWithControlsProps = props;
-  const size = DL.IS_MOBILE ? MOBILE_SIZE.TABS : "m";
-  const widgetTitle = currentTab?.title || title;
-  const widgetTitleHint = currentTab?.enableHint && currentTab?.hint?.trim() ? currentTab?.hint?.trim() : "";
-  const dispatch = useDispatch();
-  const handleExportLoading = React__default.useCallback(
-    (isLoading) => {
-      setIsExportLoading?.(isLoading);
-      dispatch(setSkipReload(isLoading));
-    },
-    [dispatch, setIsExportLoading]
-  );
-  const handleClickHint = React__default.useCallback((e) => {
-    e.stopPropagation();
-    return false;
-  }, []);
-  const renderTabs = () => {
-    if (DL.IS_MOBILE && (isFullscreen || !hideTitle && tabsItems?.length === 1)) {
-      return /* @__PURE__ */ jsxs(
-        "div",
-        {
-          className: b$1("mobile-title", {
-            "with-hint": Boolean(widgetTitleHint)
-          }),
-          children: [
-            /* @__PURE__ */ jsx("div", { className: b$1("mobile-title-wrap"), children: widgetTitle }),
-            Boolean(widgetTitleHint) && /* @__PURE__ */ jsx(
-              MarkdownHelpPopover,
-              {
-                markdown: widgetTitleHint,
-                className: b$1("chart-title-hint"),
-                onClick: handleClickHint
-              }
-            )
-          ]
-        }
-      );
-    }
-    if (hideTitle || !tabsItems || !currentTab || !onSelectTab || !widgetTitle) {
-      return null;
-    }
-    const displayedTabItems = tabsItems.map((item) => ({
-      ...item,
-      title: item.displayedTitle || item.title || ""
-    }));
-    return /* @__PURE__ */ jsx(
-      "div",
-      {
-        className: b$1(
-          "tabs",
-          { "edit-mode": editMode, "no-controls": noControls },
-          DRAGGABLE_HANDLE_CLASS_NAME
-        ),
-        children: /* @__PURE__ */ jsx(
-          AdaptiveTabs,
-          {
-            size,
-            items: displayedTabItems,
-            activeTab: currentTab.id,
-            onSelectTab,
-            breakpointsConfig: DL_ADAPTIVE_TABS_BREAK_POINT_CONFIG,
-            wrapTo: (tab, node) => {
-              const isActive = tab?.id === currentTab.id;
-              return /* @__PURE__ */ jsxs(
-                "div",
-                {
-                  className: b$1("tab", { active: isActive }),
-                  "data-qa": ChartkitMenuDialogsQA.widgetTab,
-                  children: [
-                    hideDebugTool === void 0 ? true : Boolean(hideDebugTool && !isActive) && /* @__PURE__ */ jsx(
-                      DebugInfoTool,
-                      {
-                        label: "tabId",
-                        value: tab?.id || "",
-                        modType: "right"
-                      }
-                    ),
-                    node
-                  ]
-                }
-              );
-            }
-          }
-        )
-      }
-    );
-  };
-  return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
-    !hideDebugTool && /* @__PURE__ */ jsx(DebugInfoTool, { label: "id", value: widgetId || "", modType: "outer" }),
-    /* @__PURE__ */ jsxs(
-      "div",
-      {
-        className: b$1({
-          mobile: DL.IS_MOBILE,
-          fullscreen: isFullscreen,
-          ...{ [String(extraMod)]: Boolean(extraMod) }
-        }),
-        children: [
-          isFullscreen && /* @__PURE__ */ jsx(
-            "span",
-            {
-              className: b$1("back-icon"),
-              onClick: onFullscreenClick,
-              "data-qa": "chart-widget-back-icon",
-              children: /* @__PURE__ */ jsx(Icon, { data: ArrowLeft })
-            }
-          ),
-          renderTabs(),
-          /* @__PURE__ */ jsx(
-            Header,
-            {
-              dataProvider: headerWithControlsProps.dataProvider,
-              chartsInsightsData: headerWithControlsProps.loadedData?.chartsInsightsData,
-              menuType: headerWithControlsProps.menuType,
-              customMenuOptions: {},
-              menuChartkitConfig: headerWithControlsProps.menuChartkitConfig,
-              isMenuAvailable: !noControls,
-              error: headerWithControlsProps.error || null,
-              dataProps: headerWithControlsProps.dataProps,
-              requestId: headerWithControlsProps.requestId || "",
-              chartRevIdRef: null,
-              loadedData: headerWithControlsProps.loadedData,
-              widgetDataRef: headerWithControlsProps.widgetDataRef,
-              widgetRenderTimeRef: headerWithControlsProps.widgetRenderTimeRef,
-              yandexMapAPIWaiting: headerWithControlsProps.yandexMapAPIWaiting,
-              onChange: headerWithControlsProps.onChange,
-              isWidgetMenuDataChanged: headerWithControlsProps.isWidgetMenuDataChanged,
-              onExportLoading: handleExportLoading,
-              enableActionParams: headerWithControlsProps.enableActionParams,
-              enableAssistant: headerWithControlsProps.enableAssistant,
-              onFullscreenClick,
-              showActionParamsFilter,
-              onFiltersClear,
-              canBeDisplayedFilters: true,
-              reload: headerWithControlsProps.reload
-            }
-          )
-        ]
-      }
-    )
-  ] });
-};
-const WIDGET_DEBOUNCE_TIMEOUT = 300;
-const WIDGET_RESIZE_DEBOUNCE_TIMEOUT = 600;
-const useLoadingChartWidget = (props) => {
-  const {
-    data,
-    dataProvider,
-    initialData,
-    requestId,
-    requestCancellationRef,
-    rootNodeRef,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    hasChartTabChanged,
-    hasChangedActionParams,
-    hasHideTitleChanged,
-    tabIndex,
-    adjustWidgetLayout: adjustWidgetLayout$1,
-    widgetId,
-    gridLayout,
-    layout,
-    currentTab,
-    getMarkdown,
-    noVeil,
-    noLoader,
-    compactLoader,
-    loaderDelay,
-    onStateAndParamsChange,
-    chartKitRef,
-    width,
-    height,
-    usedParamsRef,
-    innerParamsRef,
-    widgetDataRef,
-    widgetRenderTimeRef,
-    usageType,
-    enableActionParams,
-    settings,
-    clearedOuterParams
-  } = props;
-  const loadOnlyVisibleCharts = settings.loadOnlyVisibleCharts ?? true;
-  const tabs = props.tabs;
-  const [loadedDescription, setLoadedDescription] = React__default.useState(null);
-  const [description, setDescription] = React__default.useState(null);
-  const [descriptionMetaScript, setDescriptionMetaScript] = React__default.useState(null);
-  const [loadedWidgetType, setLoadedWidgetType] = React__default.useState("");
-  const [isLoadedWidgetWizard, setIsLoadedWidgetWizard] = React__default.useState(false);
-  const [isRendered, setIsRendered] = React__default.useState(false);
-  const resolveMetaDataRef = React__default.useRef();
-  const resolveWidgetDataRef = React__default.useRef();
-  const mutationObserver = React__default.useRef(null);
-  const extDashkitContext = React__default.useContext(ExtendedDashKitContext);
-  const dataProviderContextGetter = extDashkitContext?.dataProviderContextGetter || void 0;
-  const history = useHistory();
-  const location = useLocation();
-  const handleUpdate = useBeforeLoad(props.onBeforeLoad);
-  const hideTitle = Boolean(data.hideTitle);
-  const adjustLayout = React__default.useCallback(
-    (needSetDefault) => {
-      adjustWidgetLayout({
-        widgetId,
-        needSetDefault,
-        rootNode: rootNodeRef,
-        gridLayout,
-        layout,
-        cb: (...args) => {
-          return props.adjustWidgetLayout(...args);
-        }
-      });
-    },
-    [widgetId, rootNodeRef, gridLayout, adjustWidgetLayout$1]
-  );
-  const handleRenderChartWidget = React__default.useCallback(
-    (renderedData) => {
-      if (renderedData?.status === "success") {
-        pushStats(renderedData, "dash", dataProvider);
-      }
-      const newAutoHeight = isWidgetTypeWithAutoHeight(loadedWidgetType) || renderedData?.status === "error" ? tabs[tabIndex].autoHeight : false;
-      adjustLayout(!newAutoHeight);
-      setIsRendered(true);
-    },
-    [dataProvider, tabs, tabIndex, adjustLayout, loadedWidgetType]
-  );
-  const handleChangeCallback = React__default.useCallback(
-    async (changedProps) => {
-      if (changedProps.type === "PARAMS_CHANGED") {
-        onStateAndParamsChange(
-          {
-            params: changedProps.data.params || {}
-          },
-          changedProps.options
-        );
-        if (currentTab.id && changedProps.options?.action === "removeItem") {
-          onStateAndParamsChange({ state: { tabId: currentTab.id } });
-        }
-      }
-    },
-    [currentTab.id, onStateAndParamsChange]
-  );
-  const handleChartLoad = React__default.useCallback(({ data: data2 }) => {
-    setLoadedWidgetType(data2?.loadedData?.type);
-  }, []);
-  const requestHeadersGetter = React__default.useMemo(() => {
-    return dataProviderContextGetter?.bind(void 0, widgetId);
-  }, [widgetId, dataProviderContextGetter]);
-  const {
-    loadedData,
-    isLoading,
-    isSilentReload,
-    isReloadWithNoVeil,
-    error,
-    handleRenderChart,
-    handleChartkitReflow,
-    handleChange,
-    handleError,
-    handleRetry,
-    loadChartData,
-    setLoadingProps,
-    loadControls,
-    drillDownFilters,
-    drillDownLevel,
-    setCurrentDrillDownLevel,
-    yandexMapAPIWaiting,
-    setCanBeLoaded,
-    isInit,
-    isWidgetMenuDataChanged,
-    dataProps,
-    runActivity
-  } = useLoadingChart({
-    dataProvider,
-    requestHeadersGetter,
-    initialData,
-    requestId,
-    requestCancellationRef,
-    rootNodeRef,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    hasChartTabChanged,
-    hasChangedActionParams,
-    onChartLoad: handleChartLoad,
-    onChartRender: handleRenderChartWidget,
-    chartKitRef,
-    resolveMetaDataRef,
-    resolveWidgetDataRef,
-    usedParamsRef,
-    innerParamsRef,
-    handleChangeCallback,
-    widgetDataRef,
-    widgetRenderTimeRef,
-    ignoreUsedParams: true,
-    // tmp fix CHARTS-7290 TODO: CHARTS-6619 return this later with announcement of changes
-    enableActionParams,
-    clearedOuterParams
-  });
-  const {
-    mods,
-    widgetBodyClassName,
-    hasHiddenClassMod,
-    veil,
-    showLoader,
-    isFullscreen,
-    widgetType,
-    showOverlayWithControlsOnEdit,
-    noControls
-  } = React__default.useMemo(
-    () => getPreparedConstants({
-      isLoading,
-      error,
-      loadedData,
-      isReloadWithNoVeil,
-      noLoader,
-      noVeil,
-      isSilentReload,
-      history,
-      widgetId,
-      hideTitle
-    }),
-    [
-      isLoading,
-      error,
-      loadedData,
-      isReloadWithNoVeil,
-      noLoader,
-      noVeil,
-      compactLoader,
-      loaderDelay,
-      location.search,
-      hasHideTitleChanged,
-      widgetId,
-      hideTitle,
-      isSilentReload
-    ]
-  );
-  const handleToggleFullscreenMode = React__default.useCallback(() => {
-    const searchParams = new URLSearchParams(history.location.search);
-    if (searchParams.has(FOCUSED_WIDGET_PARAM_NAME)) {
-      searchParams.delete(FOCUSED_WIDGET_PARAM_NAME);
-    } else {
-      searchParams.set(FOCUSED_WIDGET_PARAM_NAME, widgetId);
-    }
-    history.push({
-      ...history.location,
-      search: searchParams.toString()
-    });
-  }, [history, widgetId]);
-  const loadDescription = React__default.useCallback(() => {
-    if (currentTab.description) {
-      getMarkdown?.({ text: currentTab.description }).then(({ result, meta }) => {
-        setLoadedDescription(meta ? { result, meta } : { result });
-      }).catch((err) => {
-        logger.logError("DashKit: Widget loadDescription failed", err);
-        setLoadedDescription({ result: currentTab.description });
-        updateImmediateLayout({
-          type: loadedWidgetType,
-          autoHeight: tabs[tabIndex].autoHeight,
-          widgetId,
-          gridLayout,
-          rootNode: rootNodeRef,
-          layout,
-          cb: props.adjustWidgetLayout
-        });
-      });
-    } else {
-      setLoadedDescription({ result: currentTab.description });
-      updateImmediateLayout({
-        type: loadedWidgetType,
-        autoHeight: tabs[tabIndex].autoHeight,
-        widgetId,
-        gridLayout,
-        rootNode: rootNodeRef,
-        layout,
-        cb: props.adjustWidgetLayout
-      });
-    }
-  }, [currentTab, getMarkdown, setLoadedDescription, loadedWidgetType, tabs, tabIndex]);
-  const isReadyToReflowRef = React__default.useRef(false);
-  isReadyToReflowRef.current = isInit && !isLoading && isRendered;
-  const debouncedChartReflow = React__default.useCallback(
-    debounce(() => {
-      handleChartkitReflow();
-      if (isReadyToReflowRef.current && handleUpdate) {
-        requestAnimationFrame(() => handleUpdate());
-      }
-    }, WIDGET_RESIZE_DEBOUNCE_TIMEOUT),
-    [handleChartkitReflow, isReadyToReflowRef]
-  );
-  React__default.useLayoutEffect(() => {
-    loadDescription();
-    return () => {
-      mutationObserver.current?.disconnect();
-    };
-  }, [loadDescription]);
-  React__default.useEffect(() => {
-    if (!hasChartTabChanged) {
-      return;
-    }
-    loadDescription();
-  }, [hasChartTabChanged, loadDescription]);
-  React__default.useEffect(() => {
-    debouncedChartReflow();
-  }, [width, height, debouncedChartReflow]);
-  const currentLayout = layout.find(({ i }) => i === widgetId);
-  const { enableDescription, background, title } = currentTab;
-  const isReadyToHandleUpdate = isInit && !isLoading && isRendered;
-  React__default.useEffect(() => {
-    if (isReadyToHandleUpdate) {
-      handleUpdate?.();
-    }
-  }, [
-    currentLayout?.x,
-    currentLayout?.y,
-    background?.color,
-    background?.enabled,
-    hideTitle,
-    title,
-    enableDescription,
-    description,
-    isReadyToHandleUpdate,
-    handleUpdate
-  ]);
-  React__default.useEffect(() => {
-    if (loadedDescription?.result === description) {
-      return;
-    }
-    if (loadedDescription) {
-      setDescription(loadedDescription.result);
-    }
-    const metaScript = loadedDescription?.meta?.script ?? null;
-    setDescriptionMetaScript(metaScript);
-    handleChartkitReflow();
-  }, [loadedDescription, description, handleChartkitReflow]);
-  const handleSelectTab = React__default.useCallback(
-    (newTabId) => {
-      if (isLoading) {
-        return;
-      }
-      if (requestCancellationRef.current?.[requestId]?.status === "loading" && requestCancellationRef.current?.[requestId]?.requestCancellation !== null) {
-        requestCancellationRef.current[requestId].status = "canceled";
-        dataProvider.cancelRequests(
-          requestCancellationRef.current[requestId].requestCancellation
-        );
-      }
-      setCurrentDrillDownLevel(0);
-      onStateAndParamsChange({
-        state: {
-          tabId: newTabId
-        }
-      });
-    },
-    [
-      onStateAndParamsChange,
-      isLoading,
-      requestId,
-      requestCancellationRef,
-      dataProvider,
-      setCurrentDrillDownLevel
-    ]
-  );
-  const getCurrentWidgetResolvedMetaInfo = React__default.useCallback(
-    (loadData) => {
-      const meta = getWidgetMeta({
-        // @ts-expect-error
-        tabs: data.tabs,
-        id: widgetId,
-        loadData,
-        savedData: loadedData,
-        error,
-        widgetDataRef
-      });
-      if (resolveMetaDataRef.current) {
-        resolveMetaDataRef.current(meta);
-      }
-    },
-    [tabs, tabIndex, resolveMetaDataRef.current, loadedData, error, widgetId]
-  );
-  const handleGetWidgetMeta = React__default.useCallback(
-    (argResolve) => {
-      resolveMetaDataRef.current = argResolve;
-      resolveWidgetDataRef.current = (resolvingData) => {
-        getCurrentWidgetResolvedMetaInfo(resolvingData);
-      };
-      if (!isInit) {
-        setCanBeLoaded(true);
-      }
-      if (!loadedData) {
-        if (error) {
-          resolveWidgetDataRef.current(null);
-        }
-        return;
-      }
-      resolveWidgetDataRef.current(loadedData);
-    },
-    [
-      error,
-      loadedData,
-      setCanBeLoaded,
-      isInit,
-      getCurrentWidgetResolvedMetaInfo,
-      resolveMetaDataRef,
-      resolveWidgetDataRef
-    ]
-  );
-  const debouncedMutationsCheck = React__default.useCallback(
-    debounce((mutations) => {
-      if (!rootNodeRef.current || !loadedWidgetType) {
-        return;
-      }
-      let needUpdate = false;
-      Array.from(mutations).forEach((mutatedItem) => {
-        if (needUpdate) {
-          return;
-        }
-        let targetEl = mutatedItem?.target;
-        const hasYfm = targetEl?.classList.contains(YFM_MARKDOWN_CLASSNAME) || targetEl?.classList.contains(YFM_CUT_MARKDOWN_CLASSNAME);
-        if (hasYfm) {
-          needUpdate = true;
-        }
-        while (!needUpdate && targetEl && rootNodeRef.current && targetEl?.parentElement !== rootNodeRef.current) {
-          targetEl = targetEl?.parentElement;
-          if (targetEl?.classList.contains(YFM_MARKDOWN_CLASSNAME)) {
-            needUpdate = true;
-          }
-        }
-      });
-      if (!needUpdate) {
-        return;
-      }
-      updateImmediateLayout({
-        type: loadedWidgetType,
-        autoHeight: tabs[tabIndex].autoHeight,
-        widgetId,
-        gridLayout,
-        rootNode: rootNodeRef,
-        layout,
-        cb: props.adjustWidgetLayout
-      });
-    }, WIDGET_DEBOUNCE_TIMEOUT),
-    [
-      rootNodeRef,
-      loadedWidgetType,
-      tabs,
-      tabIndex,
-      widgetId,
-      gridLayout,
-      layout,
-      props.adjustWidgetLayout
-    ]
-  );
-  React__default.useEffect(() => {
-    if (!isInit || !mutationObserver) {
-      return;
-    }
-    mutationObserver.current = new MutationObserver(debouncedMutationsCheck);
-    if (rootNodeRef.current) {
-      mutationObserver.current.observe(rootNodeRef.current, {
-        childList: true,
-        subtree: true,
-        attributes: true,
-        attributeFilter: ["class"]
-      });
-    }
-    return () => {
-      mutationObserver.current?.disconnect();
-    };
-  }, [debouncedMutationsCheck, mutationObserver, isInit, rootNodeRef]);
-  React__default.useEffect(() => {
-    if (loadedData?.isNewWizard && !isLoadedWidgetWizard) {
-      setIsLoadedWidgetWizard(true);
-    }
-  }, [loadedData?.isNewWizard, isLoadedWidgetWizard]);
-  const debounceResizeAdjustLayot = React__default.useCallback(
-    debounce(() => {
-      updateImmediateLayout({
-        type: loadedWidgetType,
-        autoHeight: tabs[tabIndex].autoHeight,
-        widgetId,
-        gridLayout,
-        rootNode: rootNodeRef,
-        layout,
-        cb: props.adjustWidgetLayout
-      });
-    }, WIDGET_RESIZE_DEBOUNCE_TIMEOUT),
-    [
-      widgetId,
-      loadedWidgetType,
-      tabs,
-      tabIndex,
-      gridLayout,
-      rootNodeRef,
-      layout,
-      props.adjustWidgetLayout
-    ]
-  );
-  const isAutoHeightEnabled = Boolean(tabs[tabIndex].autoHeight);
-  useResizeObserver({
-    onResize: debounceResizeAdjustLayot,
-    rootNodeRef,
-    enable: isInit && isAutoHeightEnabled
-  });
-  React__default.useEffect(() => {
-    if (loadOnlyVisibleCharts === false) {
-      setCanBeLoaded(true);
-    }
-  }, [setCanBeLoaded, loadOnlyVisibleCharts]);
-  return {
-    loadedData,
-    isLoading,
-    isInit,
-    isSilentReload,
-    isReloadWithNoVeil,
-    isAutoHeightEnabled,
-    error,
-    handleRenderChart,
-    description,
-    descriptionMetaScript,
-    handleToggleFullscreenMode,
-    handleSelectTab,
-    handleChartkitReflow,
-    handleChange,
-    handleError,
-    handleRetry,
-    handleGetWidgetMeta,
-    mods,
-    widgetBodyClassName,
-    hasHiddenClassMod,
-    veil,
-    showLoader,
-    isFullscreen,
-    loadChartData,
-    setLoadingProps,
-    loadControls,
-    drillDownFilters,
-    drillDownLevel,
-    widgetType,
-    yandexMapAPIWaiting,
-    showOverlayWithControlsOnEdit,
-    isWidgetMenuDataChanged,
-    dataProps,
-    noControls,
-    runActivity
-  };
-};
-const b = block(COMPONENT_CLASSNAME);
-const influencingProps = [
-  "dataProvider",
-  "id",
-  "source",
-  "params",
-  "config"
-];
-const ChartWidget = (props) => {
-  const {
-    data,
-    state,
-    dataProvider,
-    forwardedRef,
-    noControls,
-    nonBodyScroll,
-    transformLoadedData,
-    splitTooltip,
-    compactLoader,
-    loaderDelay,
-    id: widgetId,
-    editMode,
-    context,
-    config,
-    usageType,
-    workbookId,
-    enableAssistant,
-    onWidgetLoadData,
-    backgroundColor
-  } = props;
-  const extDashkitContext = React__default.useContext(ExtendedDashKitContext);
-  const skipReload = extDashkitContext?.skipReload ?? false;
-  const setWidgetCurrentTab = extDashkitContext?.setWidgetCurrentTab;
-  const [isWizardChart, setIsWizardChart] = React__default.useState(false);
-  const tabs = data.tabs;
-  const tabIndex = React__default.useMemo(() => getTabIndex(tabs, state.tabId), [tabs, state.tabId]);
-  const currentTab = React__default.useMemo(() => tabs[tabIndex], [tabs, tabIndex]);
-  const initName = React__default.useMemo(() => currentTab.title, [currentTab]);
-  const { chartId, enableActionParams } = currentTab;
-  const chartkitParams = React__default.useMemo(() => {
-    let res = removeEmptyNDatasetFieldsProperties(props.params);
-    if (!enableActionParams) {
-      res = pickExceptActionParamsFromParams(res);
-    }
-    return res;
-  }, [props.params, enableActionParams]);
-  const prevTabIndex = usePrevious(tabIndex);
-  const hasChartTabChanged = prevTabIndex !== void 0 && prevTabIndex !== tabIndex;
-  const prevCurrentTabDefaults = usePrevious(currentTab.params);
-  const hasCurrentTabDefaultsChanged = prevCurrentTabDefaults && !isEqual(currentTab.params, prevCurrentTabDefaults);
-  const prevHideTitle = usePrevious(data.hideTitle);
-  const hasHideTitleChanged = prevHideTitle !== void 0 && !isEqual(data.hideTitle, prevHideTitle);
-  const prevEnableActionParams = usePrevious(currentTab.enableActionParams);
-  const hasEnableActionParamsChanged = Boolean(
-    prevEnableActionParams !== void 0 && prevEnableActionParams !== currentTab.enableActionParams || prevEnableActionParams === void 0 && currentTab.enableActionParams
-  );
-  const initialData = React__default.useMemo(
-    () => getDataProviderData({
-      id: chartId,
-      config,
-      params: chartkitParams,
-      workbookId
-    }),
-    [chartId, chartkitParams, config, hasChartTabChanged, workbookId]
-  );
-  const savedForFetchProps = React__default.useMemo(() => pick(props, influencingProps), [props]);
-  const prevSavedProps = usePrevious(savedForFetchProps);
-  const prevSavedChartId = usePrevious(chartId);
-  const usedParamsRef = React__default.useRef(null);
-  const innerParamsRef = React__default.useRef(null);
-  const prevInnerParams = usePrevious(innerParamsRef?.current);
-  const hasChangedOuterProps = !prevSavedProps || !isEqual(omit(prevSavedProps, "params"), omit(pick(props, influencingProps), "params")) || Boolean(prevSavedChartId && prevSavedChartId !== chartId) || hasEnableActionParamsChanged;
-  let hasChangedActionParams = false;
-  const hasChangedOuterParams = React__default.useMemo(() => {
-    const propsParams = props.params;
-    const prevSavedPropsParams = prevSavedProps?.params;
-    const isEqualParamsWithPrev = prevSavedProps && isEqual(prevSavedPropsParams, propsParams);
-    let changedParams = !prevSavedProps || !isEqualParamsWithPrev;
-    let isOuterAndInnerParamsEqual = false;
-    let isOuterAndInnerActionParamsEqual = true;
-    if (changedParams && innerParamsRef?.current) {
-      const innerFullParams = innerParamsRef?.current;
-      const outerFullParams = propsParams;
-      isOuterAndInnerParamsEqual = isEqual(innerFullParams, outerFullParams);
-      const innerActionParams = pickActionParamsFromParams(innerFullParams, true);
-      const outerActionParams = pickActionParamsFromParams(outerFullParams, true);
-      isOuterAndInnerActionParamsEqual = isEqual(innerActionParams, outerActionParams);
-      if (!isOuterAndInnerActionParamsEqual) {
-        hasChangedActionParams = true;
-      }
-    }
-    if (isOuterAndInnerParamsEqual && isOuterAndInnerActionParamsEqual) {
-      changedParams = false;
-    }
-    return changedParams;
-  }, [prevSavedProps?.params, props.params, usedParamsRef, innerParamsRef, isWizardChart]);
-  const clearedOuterParams = React__default.useMemo(() => {
-    let clearedParams;
-    const propsParams = props.params;
-    const prevSavedPropsParams = prevSavedProps?.params;
-    const isEqualParamsWithPrev = prevSavedProps && isEqual(prevSavedPropsParams, propsParams);
-    const hasParamsChanged = !prevSavedProps || !isEqualParamsWithPrev;
-    const isOuterAndInnerParamsEqual = hasParamsChanged && innerParamsRef?.current ? isEqual(innerParamsRef?.current, propsParams) : false;
-    if (!hasChangedActionParams && !isOuterAndInnerParamsEqual) {
-      clearedParams = prevSavedProps ? Object.keys(omit(prevSavedProps.params, Object.keys(props?.params || {}))) : [];
-    }
-    return clearedParams;
-  }, [
-    hasChangedActionParams,
-    prevSavedProps?.params,
-    props.params,
-    usedParamsRef,
-    innerParamsRef,
-    isWizardChart
-  ]);
-  const hasChangedInnerParamsFromInside = React__default.useMemo(() => {
-    return prevInnerParams && !isEqual(innerParamsRef?.current, prevInnerParams);
-  }, [prevInnerParams, innerParamsRef?.current]);
-  const requestId = React__default.useMemo(
-    () => settings_default.requestIdGenerator(DL.REQUEST_ID_PREFIX),
-    [
-      hasChangedOuterParams,
-      hasChangedOuterProps,
-      hasChangedActionParams,
-      hasChartTabChanged,
-      hasChangedInnerParamsFromInside
-    ]
-  );
-  const currentActionParams = enableActionParams && chartkitParams && pickActionParamsFromParams(chartkitParams, true) || {};
-  const showActionParamsFilter = !isEmpty(
-    Object.values(currentActionParams).filter((item) => {
-      if (typeof item === "string") {
-        return !isEmpty(item);
-      }
-      if (typeof item === "number") {
-        return true;
-      }
-      return !isEmpty(item.filter((paramItem) => !isEmpty(paramItem.trim())));
-    })
-  );
-  const requestCancellationRef = React__default.useRef({
-    [requestId]: {
-      requestCancellation: dataProvider.getRequestCancellation(),
-      status: "unset"
-    }
-  });
-  React__default.useEffect(() => {
-    requestCancellationRef.current[requestId] = {
-      requestCancellation: dataProvider.getRequestCancellation(),
-      status: "unset"
-    };
-  }, [requestCancellationRef, dataProvider, requestId]);
-  const rootNodeRef = React__default.useRef(null);
-  const chartKitRef = React__default.useRef(null);
-  const widgetDataRef = React__default.useRef(null);
-  const widgetRenderTimeRef = React__default.useRef(null);
-  const [initialParams, setInitialParams] = React__default.useState({});
-  const [isExportLoading, setIsExportLoading] = React__default.useState(false);
-  const {
-    loadedData,
-    error,
-    handleRenderChart,
-    mods,
-    widgetBodyClassName,
-    hasHiddenClassMod,
-    veil,
-    showLoader,
-    isFullscreen,
-    isAutoHeightEnabled,
-    description,
-    descriptionMetaScript,
-    handleToggleFullscreenMode,
-    handleSelectTab,
-    handleGetWidgetMeta,
-    handleChartkitReflow,
-    handleChange,
-    handleError,
-    handleRetry,
-    loadChartData,
-    setLoadingProps,
-    loadControls,
-    drillDownFilters,
-    drillDownLevel,
-    widgetType,
-    yandexMapAPIWaiting,
-    isLoading,
-    isInit,
-    showOverlayWithControlsOnEdit,
-    isWidgetMenuDataChanged,
-    dataProps,
-    noControls: urlNoControls,
-    runActivity
-  } = useLoadingChartWidget({
-    ...props,
-    chartKitRef,
-    rootNodeRef,
-    initialData,
-    requestId,
-    requestCancellationRef,
-    hasChangedOuterProps,
-    hasChangedOuterParams,
-    hasChartTabChanged,
-    hasChangedActionParams,
-    hasHideTitleChanged,
-    tabIndex,
-    tabs,
-    widgetId,
-    currentTab,
-    usedParamsRef,
-    innerParamsRef,
-    widgetDataRef,
-    widgetRenderTimeRef,
-    usageType,
-    enableActionParams,
-    clearedOuterParams
-  });
-  React__default.useEffect(() => {
-    if (loadedData && onWidgetLoadData) {
-      onWidgetLoadData(widgetId, loadedData, widgetDataRef);
-    }
-  }, [loadedData, widgetId, onWidgetLoadData]);
-  const handleFiltersClear = React__default.useCallback(() => {
-    const newActionParams = {};
-    Object.keys(chartkitParams || {}).forEach(function(key) {
-      newActionParams[key] = "";
-    });
-    handleChange(
-      {
-        type: "PARAMS_CHANGED",
-        data: { params: pickActionParamsFromParams(newActionParams, true) }
-      },
-      { forceUpdate: false },
-      true,
-      true
-    );
-  }, [handleChange, chartkitParams]);
-  React__default.useEffect(() => {
-    if (hasEnableActionParamsChanged && !enableActionParams) {
-      handleFiltersClear();
-    }
-  }, [hasEnableActionParamsChanged, enableActionParams, handleFiltersClear]);
-  React__default.useEffect(() => {
-    if (loadedData?.isNewWizard && !isWizardChart) {
-      setIsWizardChart(true);
-    }
-  }, [loadedData?.isNewWizard, isWizardChart]);
-  React__default.useEffect(() => {
-    if (!hasCurrentTabDefaultsChanged && !loadedData) {
-      return;
-    }
-    setInitialParams({ ...loadedData?.defaultParams, ...currentTab.params });
-  }, [hasCurrentTabDefaultsChanged, currentTab.params, loadedData, loadedData?.defaultParams]);
-  React__default.useEffect(() => {
-    setWidgetCurrentTab?.({ widgetId, tabId: currentTab.id });
-  }, [currentTab, setWidgetCurrentTab, widgetId]);
-  const handleClickHint = (e) => {
-    e.stopPropagation();
-    return false;
-  };
-  const adaptiveTabsItems = React__default.useMemo(
-    () => tabs.map((item) => ({
-      id: item.id,
-      title: item.title.trim() || "—",
-      displayedTitle: /* @__PURE__ */ jsxs("span", { className: b("chart-title-wrap"), children: [
-        /* @__PURE__ */ jsx(
-          "span",
-          {
-            className: b("chart-title-text", {
-              "with-hint": Boolean(item.hint && item.enableHint)
-            }),
-            children: (typeof item.title === "string" ? item.title.trim() : item.title) || "—"
-          }
-        ),
-        item.enableHint && item.hint && /* @__PURE__ */ jsx(
-          MarkdownHelpPopover,
-          {
-            markdown: item.hint,
-            className: b("chart-title-hint"),
-            onClick: handleClickHint
-          }
-        )
-      ] }),
-      disabled: Boolean(isLoading)
-    })),
-    [tabs, isLoading]
-  );
-  const reload = React__default.useCallback(
-    (args = {}) => {
-      if (skipReload) {
-        return;
-      }
-      setLoadingProps(args);
-      loadChartData();
-    },
-    [loadChartData, setLoadingProps, skipReload]
-  );
-  React__default.useImperativeHandle(
-    forwardedRef,
-    () => ({
-      props,
-      reflow: handleChartkitReflow,
-      reload,
-      getMeta: () => new Promise((resolve) => handleGetWidgetMeta(resolve)),
-      getCurrentTabChartId: () => chartId || ""
-    }),
-    [
-      forwardedRef,
-      handleChartkitReflow,
-      handleGetWidgetMeta,
-      reload,
-      chartId,
-      loadedData
-      // loadedData in deps for meta actual data
-    ]
-  );
-  const menuChartkitConfig = React__default.useMemo(
-    () => ({
-      config: {
-        canEdit: context.canEdit
-      },
-      chartsDataProvider: dataProvider
-    }),
-    [context.canEdit, editMode, context.entryDialoguesRef, initName]
-  );
-  const widgetDashState = React__default.useMemo(() => {
-    if (widgetType !== "table") {
-      return void 0;
-    }
-    return {
-      isPreviewMode: editMode
-    };
-  }, [editMode, widgetType]);
-  const disableControls = noControls || urlNoControls;
-  const commonHeaderContentProps = {
-    compactLoader,
-    loaderDelay,
-    menuType: "dash",
-    menuChartkitConfig,
-    dataProvider,
-    error,
-    dataProps,
-    requestId,
-    loadedData,
-    widgetDataRef,
-    widgetRenderTimeRef,
-    yandexMapAPIWaiting,
-    enableActionParams,
-    enableAssistant,
-    isWidgetMenuDataChanged,
-    onChange: handleChange,
-    onFullscreenClick: handleToggleFullscreenMode,
-    showActionParamsFilter,
-    noControls: disableControls,
-    onFiltersClear: handleFiltersClear,
-    reload
-  };
-  const withInsights = Boolean(loadedData?.chartsInsightsData);
-  const withFiltering = Boolean(showActionParamsFilter);
-  const withBtnsMod = withInsights && withFiltering ? "btns-full" : withInsights || withFiltering ? "btns-partly" : "";
-  const widgetHeaderProps = {
-    isFullscreen,
-    editMode,
-    hideTitle: Boolean(data.hideTitle),
-    tabsItems: adaptiveTabsItems,
-    currentTab,
-    onSelectTab: handleSelectTab,
-    widgetId,
-    hideDebugTool: true,
-    ...commonHeaderContentProps,
-    setIsExportLoading,
-    showLoader,
-    veil,
-    extraMod: withBtnsMod
-  };
-  const showContentLoader = widgetHeaderProps.showLoader || isExportLoading;
-  const showLoaderVeil = widgetHeaderProps.showLoader && widgetHeaderProps.veil && !isExportLoading;
-  const isFirstLoadingFloat = loadedData === null;
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      ref: rootNodeRef,
-      className: `${b({
-        ...mods,
-        autoheight: isAutoHeightEnabled,
-        ["wait-for-init"]: !isInit,
-        "default-mobile": DL.IS_MOBILE && !isFullscreen,
-        pulsate: (showContentLoader || showLoaderVeil) && !isFirstLoadingFloat,
-        "loading-mobile-height": DL.IS_MOBILE && isFirstLoadingFloat
-      })}`,
-      "data-qa": ChartkitMenuDialogsQA.chartWidget,
-      "data-qa-mod": isFullscreen ? "fullscreen" : "",
-      children: [
-        /* @__PURE__ */ jsx(
-          DebugInfoTool,
-          {
-            data: [
-              { label: "widgetId", value: widgetId },
-              { label: "tabId", value: currentTab.id },
-              { label: "chartId", value: chartId }
-            ]
-          }
-        ),
-        /* @__PURE__ */ jsx(WidgetHeader, { ...widgetHeaderProps }),
-        isFirstLoadingFloat && /* @__PURE__ */ jsx(
-          Loader,
-          {
-            visible: showContentLoader,
-            compact: false,
-            size: "s",
-            veil: false,
-            delay: 1e3
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          Content,
-          {
-            initialParams,
-            showLoader,
-            showOverlayWithControlsOnEdit,
-            veil,
-            widgetBodyClassName,
-            hasHiddenClassMod,
-            chartId,
-            transformLoadedData,
-            splitTooltip: splitTooltip || isFullscreen,
-            nonBodyScroll,
-            onRender: handleRenderChart,
-            onRetry: handleRetry,
-            onError: handleError,
-            forwardedRef: chartKitRef,
-            getControls: loadControls,
-            drillDownFilters,
-            drillDownLevel,
-            widgetType,
-            widgetDashState,
-            rootNodeRef,
-            backgroundColor,
-            needRenderContentControls: false,
-            chartRevIdRef: null,
-            runActivity,
-            ...commonHeaderContentProps
-          }
-        ),
-        Boolean(description || loadedData?.publicAuthor) && /* @__PURE__ */ jsx(
-          WidgetFooter,
-          {
-            isFullscreen: Boolean(isFullscreen),
-            description: description || "",
-            metaScripts: descriptionMetaScript,
-            enableDescription: currentTab.enableDescription,
-            author: loadedData?.publicAuthor
-          }
-        )
-      ]
-    }
-  );
-};
-function isChartType(props) {
-  return props.usageType === "chart";
-}
-function isSelectorType(props) {
-  return props.usageType === "control";
-}
-class ChartWrapper extends React__default.Component {
-  constructor(props) {
-    super(props);
-    this.dataProvider = chartsDataProvider;
-  }
-  render() {
-    if (isChartType(this.props)) {
-      return /* @__PURE__ */ createElement(
-        Chart,
-        {
-          ...this.props,
-          dataProvider: this.dataProvider,
-          ignoreUsedParams: true,
-          key: "chart"
-        }
-      );
-    }
-    if (isSelectorType(this.props)) {
-      return /* @__PURE__ */ createElement(
-        ChartSelector,
-        {
-          ...this.props,
-          dataProvider: this.dataProvider,
-          key: "selector"
-        }
-      );
-    }
-    const props = this.props;
-    return /* @__PURE__ */ createElement(
-      ChartWidget,
-      {
-        ...props,
-        dataProvider: this.dataProvider,
-        compactLoader: true,
-        key: "widget"
-      }
-    );
-  }
-}
-export {
-  ChartWrapper as C,
-  DATALENS_DEBUG_MODE_KEY as D,
-  SNAPTER_DESIRED_CLASS as S,
-  WidgetHeader as W,
-  X_CSRF_TOKEN_HEADER as X,
-  COMPONENT_CLASSNAME as a,
-  getDefaultChartMenu as b,
-  getPanePreviewChartMenu as c,
-  getWizardChartMenu as d,
-  getChartkitMenu as e,
-  getChartkitMenuByType as g,
-  pushStats as p
-};