@retailcrm/datalens-ui 0.0.0

package/components/Widgets.js

@@ -0,0 +1,3964 @@
+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
+};