@retailcrm/datalens-ui 0.0.0

package/components/EntryDialogues.js

@@ -0,0 +1,2515 @@
+import React__default from "react";
+import noop from "lodash/noop";
+import { l as logger, U as Utils, a2 as selectEntryContent, d as showToast, g as getSdk, a3 as selectLockToken, J as reachMetricaGoal, K as GoalId, L as CounterName, O as navigateHelper_default, a4 as useRefMounted, Z as groupEntitiesByScope, h as formDocsEndpointDL, D as sdk } from "./ActionPanel.js";
+import { r as registry, l as I18n, c9 as ErrorContentTypes, ca as normalizeDestination, cb as EntryDialogQA, d as EntryScope, cc as DialogCreateWorkbookEntryQa, cd as DialogDraftWarningQA, D as DL, ce as CLIPBOARD_TIMEOUT, g as getEntryNameByKey, j as i18n$m } from "./AccessRights.js";
+import { D as DialogRelatedEntities } from "./DialogRelatedEntities.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Dialog, Alert, TextInput, Button, Icon, Loader, Popover, CopyToClipboard, Link, Switch } from "@gravity-ui/uikit";
+import block from "bem-cn-lite";
+import { E as ErrorContent } from "./ErrorContent.js";
+import { connect, useDispatch } from "react-redux";
+import { I as Interpolate } from "./Interpolate.js";
+import { TriangleExclamationFill, TriangleExclamation } from "@gravity-ui/icons";
+import { aM as copyDash, aN as isDeprecatedDashData, aO as isEntryAlreadyExists, aP as cleanLock, aQ as DashUpdateStatus } from "./ControlComponents.js";
+import { S as SelectMigrationToWorkbookDialog } from "./SelectMigrationToWorkbookDialog.js";
+import { P as PathSelect } from "./PathSelect.js";
+import { Y as YfmWrapper } from "./YfmWrapper.js";
+import { FormRow } from "@gravity-ui/components";
+import { E as EntryIcon } from "./EntryIcon.js";
+import { toaster } from "@gravity-ui/uikit/toaster-singleton";
+import { E as EntryRow } from "./EntryRow.js";
+import { E as EntryTitle } from "./EntryTitle.js";
+const DialogAccess = (props) => {
+  const { AccessRights } = registry.common.components.getAll();
+  return /* @__PURE__ */ jsx(AccessRights, { ...props });
+};
+var EntryDialogResolveStatus = /* @__PURE__ */ ((EntryDialogResolveStatus2) => {
+  EntryDialogResolveStatus2["Success"] = "success";
+  EntryDialogResolveStatus2["Close"] = "close";
+  return EntryDialogResolveStatus2;
+})(EntryDialogResolveStatus || {});
+const i18n$l = I18n.keyset("datalens.landing.error");
+const b$f = block("dialog-access-description");
+const DialogAccessDescription = ({
+  visible,
+  onClose,
+  accessDescription
+}) => {
+  const handleClose = () => {
+    onClose({ status: EntryDialogResolveStatus.Close });
+  };
+  return /* @__PURE__ */ jsxs(Dialog, { open: visible, onClose: handleClose, className: b$f(), children: [
+    /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n$l("label_title-forbidden-entry") }),
+    /* @__PURE__ */ jsx(Dialog.Body, { className: b$f("body"), children: /* @__PURE__ */ jsx(
+      ErrorContent,
+      {
+        type: ErrorContentTypes.NO_ENTRY_ACCESS,
+        accessDescription,
+        showDebugInfo: false,
+        hideTitle: true
+      }
+    ) })
+  ] });
+};
+const b$e = block("dl-entry-dialog-base");
+const i18n$k = I18n.keyset("validation");
+const _EntryDialogBase = class _EntryDialogBase extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      visible: this.props.visible,
+      name: this.props.name,
+      path: this.props.path,
+      progress: false,
+      inputError: false
+    };
+    this.textInputRef = React__default.createRef();
+    this.isUnmounted = false;
+    this.onApply = async () => {
+      this.setState({ progress: true });
+      const { name: stateName } = this.state;
+      const path = normalizeDestination(this.state.path);
+      const name = (stateName === "" ? this.props.defaultName : stateName).trim();
+      let key = path;
+      if (this.props.withInput) {
+        key = path === "/" ? name : path + name;
+      }
+      if (name.includes("/")) {
+        const errorMsg = i18n$k("label_validation-slash_error");
+        logger.logError("EntryDialogBase: onApply failed", {
+          name: "Validation error",
+          message: errorMsg
+        });
+        this.setState({ progress: false, inputError: errorMsg });
+        return;
+      }
+      try {
+        const data = await this.props.onApply(
+          key,
+          name,
+          name === "" ? path : Utils.getPathBefore({ path: key })
+        );
+        this.props.onSuccess(data);
+        if (this.isUnmounted) {
+          return;
+        }
+        this.setState({ progress: false });
+      } catch (error) {
+        logger.logError("EntryDialogBase: onApply failed", error);
+        const errorReturn = this.props.onError(error);
+        const inputError = errorReturn?.inputError || false;
+        if (this.isUnmounted) {
+          return;
+        }
+        this.setState({ progress: false, inputError });
+      }
+    };
+    this.onClose = () => {
+      if (this.state.progress) {
+        return;
+      }
+      this.props.onClose();
+    };
+    this.onChoosePath = (value) => {
+      this.setState({ path: normalizeDestination(value), inputError: false });
+      if (!this.isUnmounted) {
+        this.textInputRef.current?.focus();
+      }
+    };
+    this.onChangeInput = (value) => {
+      this.setState({ name: value, inputError: false });
+    };
+  }
+  static getDerivedStateFromProps(props, state) {
+    if (props.visible !== state.visible) {
+      return {
+        visible: props.visible,
+        name: props.name,
+        path: props.path,
+        progress: false
+      };
+    }
+    return null;
+  }
+  componentDidMount() {
+    this.textInputRef.current?.focus();
+  }
+  componentDidUpdate({ visible: prevVisible }) {
+    const { visible } = this.props;
+    if (visible && visible !== prevVisible) {
+      this.textInputRef.current?.focus();
+    }
+  }
+  componentWillUnmount() {
+    this.isUnmounted = true;
+  }
+  render() {
+    const {
+      caption,
+      withInput,
+      visible,
+      placeholder,
+      textButtonApply,
+      textButtonCancel,
+      inactiveEntryKeys,
+      children,
+      warningMessage,
+      confirmButtonView,
+      initialFocus
+    } = this.props;
+    return /* @__PURE__ */ jsxs(
+      Dialog,
+      {
+        size: "s",
+        open: visible,
+        onClose: this.onClose,
+        onEnterKeyDown: this.onApply,
+        initialFocus,
+        children: [
+          /* @__PURE__ */ jsx(Dialog.Header, { caption }),
+          /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsxs("div", { "data-qa": EntryDialogQA.Content, children: [
+            children ? children : /* @__PURE__ */ jsx(
+              PathSelect,
+              {
+                size: "l",
+                defaultPath: this.state.path,
+                withInput,
+                onChoosePath: this.onChoosePath,
+                inputRef: this.textInputRef,
+                inputValue: this.state.name,
+                inputError: this.state.inputError,
+                onChangeInput: this.onChangeInput,
+                placeholder,
+                inactiveEntryKeys,
+                entryScope: this.props.entryScope
+              }
+            ),
+            warningMessage && /* @__PURE__ */ jsx("div", { className: b$e("warning"), children: /* @__PURE__ */ jsx(Alert, { theme: "warning", message: warningMessage, view: "outlined" }) })
+          ] }) }),
+          /* @__PURE__ */ jsx(
+            Dialog.Footer,
+            {
+              onClickButtonCancel: this.onClose,
+              onClickButtonApply: this.onApply,
+              propsButtonApply: { qa: EntryDialogQA.Apply, view: confirmButtonView },
+              textButtonApply,
+              textButtonCancel,
+              loading: this.state.progress
+            }
+          )
+        ]
+      }
+    );
+  }
+};
+_EntryDialogBase.defaultProps = {
+  name: "",
+  defaultName: "",
+  path: "/",
+  withInput: true,
+  confirmButtonView: "action"
+};
+let EntryDialogBase = _EntryDialogBase;
+const i18n$j = I18n.keyset("component.dialog-copy-entry.view");
+const getCaption = (scope) => {
+  switch (scope) {
+    case EntryScope.Dash:
+      return i18n$j("section_caption-dashboard");
+    case EntryScope.Widget:
+      return i18n$j("section_caption-widget");
+    default:
+      return i18n$j("section_caption");
+  }
+};
+class DialogCopyEntry extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.getWarningMessage = () => {
+      if (this.props.scope === EntryScope.Dash && this.props.entryContent.data && isDeprecatedDashData(this.props.entryContent.data)) {
+        return i18n$j("dialog_dash-deprecation-copy-text");
+      }
+      return null;
+    };
+    this.onApply = async (_, name, path) => {
+      let copiedEntry;
+      const { scope } = this.props;
+      if (scope === EntryScope.Dataset) {
+        const new_key = path + name;
+        const { id } = await getSdk().sdk.bi.copyDataset({
+          datasetId: this.props.entryId,
+          new_key
+        });
+        copiedEntry = {
+          entryId: id,
+          scope,
+          key: new_key
+        };
+      } else if (scope === EntryScope.Dash) {
+        const { workbookId, copyDash: copyDash2 } = this.props;
+        const entry = await copyDash2({
+          entryId: this.props.entryId,
+          ...workbookId ? { workbookId } : {},
+          name,
+          key: path + name
+        });
+        copiedEntry = {
+          entryId: entry.entryId,
+          scope,
+          key: entry.key,
+          type: entry.type
+        };
+      } else {
+        const data = await getSdk().sdk.us.copyEntry({
+          entryId: this.props.entryId,
+          name,
+          destination: path
+        });
+        const entry = data[0];
+        copiedEntry = {
+          entryId: entry.entryId,
+          scope,
+          key: entry.key,
+          type: entry.type
+        };
+      }
+      return copiedEntry;
+    };
+    this.onApplyCreateWorkbookEntry = async ({ name }) => {
+      const { scope, entryId } = this.props;
+      const newEntry = await getSdk().sdk.us.copyWorkbookEntry({
+        entryId,
+        name
+      });
+      return {
+        entryId: newEntry.entryId,
+        scope,
+        key: newEntry.key,
+        type: newEntry.type
+      };
+    };
+    this.onError = (error) => {
+      if (isEntryAlreadyExists(error)) {
+        return {
+          inputError: i18n$j("label_entry-name-already-exists")
+        };
+      }
+      this.props.showToast({
+        title: i18n$j("toast_copy-failed"),
+        name: "DialogCopyEntryFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Success, data });
+    };
+  }
+  render() {
+    const { workbookId, scope } = this.props;
+    if (workbookId) {
+      const name = `${this.props.initName} - ${i18n$j("label_copy")}`;
+      const defaultName = `${i18n$j("label_default-name")} - ${i18n$j("label_copy")}`;
+      return /* @__PURE__ */ jsx(
+        DialogCreateWorkbookEntry,
+        {
+          name: name || defaultName,
+          defaultName,
+          caption: getCaption(scope),
+          textButtonApply: i18n$j("button_apply"),
+          textButtonCancel: i18n$j("button_cancel"),
+          visible: this.props.visible,
+          onClose: this.onClose,
+          onApply: this.onApplyCreateWorkbookEntry,
+          onSuccess: this.onSuccess,
+          onError: this.onError,
+          placeholder: i18n$j("label_placeholder"),
+          warningMessage: this.getWarningMessage()
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        withInput: true,
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        path: this.props.initDestination,
+        name: this.props.initName,
+        defaultName: i18n$j("label_default-name"),
+        caption: i18n$j("section_caption"),
+        textButtonCancel: i18n$j("button_cancel"),
+        textButtonApply: i18n$j("button_apply"),
+        placeholder: i18n$j("label_placeholder"),
+        warningMessage: this.getWarningMessage(),
+        initialFocus: 1
+      }
+    );
+  }
+}
+const mapDispatchToProps$9 = {
+  showToast,
+  copyDash
+};
+const DialogCopyEntry$1 = connect(
+  (state) => ({
+    entryContent: selectEntryContent(state)
+  }),
+  mapDispatchToProps$9
+)(DialogCopyEntry);
+const b$d = block("dl-dialog-create-workbook-entry");
+const i18n$i = I18n.keyset("component.dialog-create-workbook-entry.view");
+const _DialogCreateWorkbookEntry = class _DialogCreateWorkbookEntry extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      name: this.props.name,
+      loading: false,
+      inputError: false
+    };
+    this.textInputRef = React__default.createRef();
+    this.isUnmounted = false;
+    this.onApply = async () => {
+      this.setState({ loading: true });
+      const { name: stateName } = this.state;
+      const name = (stateName === "" ? this.props.defaultName : stateName).trim();
+      try {
+        const data = await this.props.onApply({
+          name,
+          workbookId: this.props.workbookId,
+          collectionId: this.props.collectionId
+        });
+        this.props.onSuccess(data);
+        if (this.isUnmounted) {
+          return;
+        }
+        this.setState({ loading: false });
+      } catch (error) {
+        logger.logError("DialogCreateWorkbookEntry: onApply failed", error);
+        const errorReturn = this.props.onError?.(error);
+        const inputError = errorReturn?.inputError || false;
+        if (this.isUnmounted) {
+          return;
+        }
+        this.setState({ loading: false, inputError });
+      }
+    };
+    this.onClose = () => {
+      if (this.state.loading) {
+        return;
+      }
+      this.props.onClose();
+    };
+    this.onUpdateInput = (name) => this.setState({ name, inputError: false });
+  }
+  componentDidMount() {
+    this.textInputRef.current?.focus();
+  }
+  componentDidUpdate({ visible: prevVisible }) {
+    const { visible } = this.props;
+    if (visible && visible !== prevVisible) {
+      this.textInputRef.current?.focus();
+      if (this.state.inputError) {
+        this.setState({ inputError: false });
+      }
+    }
+  }
+  componentWillUnmount() {
+    this.isUnmounted = true;
+  }
+  render() {
+    const {
+      caption,
+      visible,
+      placeholder,
+      textButtonApply,
+      textButtonCancel,
+      children,
+      warningMessage,
+      confirmButtonView
+    } = this.props;
+    const { name, loading, inputError } = this.state;
+    return /* @__PURE__ */ jsxs(
+      Dialog,
+      {
+        qa: DialogCreateWorkbookEntryQa.Root,
+        size: "s",
+        open: visible,
+        onClose: this.onClose,
+        onEnterKeyDown: this.onApply,
+        children: [
+          /* @__PURE__ */ jsx(Dialog.Header, { caption }),
+          /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsxs("div", { className: b$d("content"), "data-qa": "dialog-create-workbook-entry", children: [
+            children ? children : /* @__PURE__ */ jsxs("div", { className: b$d("row"), children: [
+              /* @__PURE__ */ jsx("span", { className: b$d("row-label"), children: i18n$i("label_name") }),
+              /* @__PURE__ */ jsx(
+                TextInput,
+                {
+                  qa: DialogCreateWorkbookEntryQa.Input,
+                  controlRef: this.textInputRef,
+                  value: name,
+                  placeholder,
+                  onUpdate: this.onUpdateInput,
+                  error: inputError
+                }
+              )
+            ] }),
+            warningMessage && /* @__PURE__ */ jsx("div", { className: b$d("warning"), children: /* @__PURE__ */ jsx(Alert, { theme: "warning", message: warningMessage, view: "outlined" }) })
+          ] }) }),
+          /* @__PURE__ */ jsx(
+            Dialog.Footer,
+            {
+              onClickButtonCancel: this.onClose,
+              onClickButtonApply: this.onApply,
+              propsButtonApply: {
+                qa: DialogCreateWorkbookEntryQa.ApplyButton,
+                view: confirmButtonView
+              },
+              textButtonApply,
+              textButtonCancel,
+              loading
+            }
+          )
+        ]
+      }
+    );
+  }
+};
+_DialogCreateWorkbookEntry.defaultProps = {
+  name: "",
+  defaultName: "",
+  confirmButtonView: "action"
+};
+let DialogCreateWorkbookEntry = _DialogCreateWorkbookEntry;
+const i18n$h = I18n.keyset("component.dialog-create-dashboard.view");
+class DialogCreateDashboard extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.onWorkbookApply = ({ name }) => {
+      const { workbookId, data, annotation } = this.props;
+      return this.props.sdk.charts.createDash({
+        data: {
+          workbookId,
+          name,
+          data,
+          annotation
+        }
+      });
+    };
+    this.onApply = async (key) => {
+      const { data, annotation } = this.props;
+      const response = await this.props.sdk.charts.createDash({
+        data: { key, data, annotation }
+      });
+      return response;
+    };
+    this.onError = (error) => {
+      if (isEntryAlreadyExists(error)) {
+        return {
+          inputError: i18n$h("label_entry-name-already-exists")
+        };
+      }
+      this.props.showToast({
+        title: i18n$h("toast_create-dashboard-failed"),
+        name: "DialogCreateDashboardFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Success, data });
+    };
+  }
+  render() {
+    const { workbookId } = this.props;
+    if (workbookId) {
+      return /* @__PURE__ */ jsx(
+        DialogCreateWorkbookEntry,
+        {
+          name: i18n$h("label_default-name"),
+          defaultName: i18n$h("label_default-name"),
+          caption: i18n$h("section_caption"),
+          textButtonApply: i18n$h("button_apply"),
+          textButtonCancel: i18n$h("button_cancel"),
+          visible: this.props.visible,
+          onClose: this.onClose,
+          onApply: this.onWorkbookApply,
+          onSuccess: this.onSuccess,
+          onError: this.onError
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        withInput: true,
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        path: this.props.initDestination,
+        name: i18n$h("label_default-name"),
+        defaultName: i18n$h("label_default-name"),
+        caption: i18n$h("section_caption"),
+        textButtonCancel: i18n$h("button_cancel"),
+        textButtonApply: i18n$h("button_apply"),
+        placeholder: i18n$h("label_placeholder")
+      }
+    );
+  }
+}
+const mapDispatchToProps$8 = {
+  showToast
+};
+const DialogCreateDashboard$1 = connect(null, mapDispatchToProps$8)(DialogCreateDashboard);
+const i18n$g = I18n.keyset("component.dialog-create-editor-chart.view");
+class DialogCreateEditorChart extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.onApply = async (key) => {
+      const { data, type, annotation } = this.props;
+      return getSdk().sdk.mix.createEditorChart({
+        key,
+        data: data || {},
+        type,
+        annotation
+      });
+    };
+    this.onWorkbookApply = ({ name }) => {
+      const { workbookId, annotation } = this.props;
+      return getSdk().sdk.mix.createEditorChart({
+        name,
+        workbookId,
+        data: this.props.data || {},
+        type: this.props.type,
+        annotation
+      });
+    };
+    this.onError = (error) => {
+      if (isEntryAlreadyExists(error)) {
+        return {
+          inputError: i18n$g("label_entry-name-already-exists")
+        };
+      }
+      this.props.showToast({
+        title: i18n$g("toast_create-editor-chart-failed"),
+        name: "DialogCreateEditorChartFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Success, data });
+    };
+  }
+  render() {
+    if (this.props.workbookId) {
+      return /* @__PURE__ */ jsx(
+        DialogCreateWorkbookEntry,
+        {
+          caption: i18n$g("section_caption"),
+          defaultName: i18n$g("label_default-name"),
+          name: this.props.initName,
+          placeholder: i18n$g("label_placeholder"),
+          textButtonApply: i18n$g("button_apply"),
+          textButtonCancel: i18n$g("button_cancel"),
+          visible: this.props.visible,
+          onClose: this.onClose,
+          onError: this.onError,
+          onSuccess: this.onSuccess,
+          onApply: this.onWorkbookApply
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        withInput: true,
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        path: this.props.initDestination,
+        name: this.props.initName,
+        defaultName: i18n$g("label_default-name"),
+        caption: i18n$g("section_caption"),
+        textButtonCancel: i18n$g("button_cancel"),
+        textButtonApply: i18n$g("button_apply"),
+        placeholder: i18n$g("label_placeholder")
+      }
+    );
+  }
+}
+const mapDispatchToProps$7 = {
+  showToast
+};
+const DialogCreateEditorChart$1 = connect(null, mapDispatchToProps$7)(DialogCreateEditorChart);
+const i18n$f = I18n.keyset("component.dialog-create-folder.view");
+class DialogCreateFolder extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.onApply = async (key) => {
+      const data = await getSdk().sdk.us.createFolder({ key });
+      return data;
+    };
+    this.onError = (error) => {
+      if (isEntryAlreadyExists(error)) {
+        return {
+          inputError: i18n$f("label_folder-already-exists")
+        };
+      }
+      this.props.showToast({
+        title: i18n$f("toast_create-folder-failed"),
+        name: "DialogCreateFolderFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Success, data });
+    };
+  }
+  render() {
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        withInput: true,
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        path: this.props.initDestination,
+        name: this.props.initName,
+        defaultName: i18n$f("label_default-name"),
+        caption: i18n$f("section_caption"),
+        textButtonCancel: i18n$f("button_cancel"),
+        textButtonApply: i18n$f("button_apply"),
+        placeholder: i18n$f("label_placeholder"),
+        entryScope: EntryScope.Folder
+      }
+    );
+  }
+}
+const mapDispatchToProps$6 = {
+  showToast
+};
+const DialogCreateFolder$1 = connect(null, mapDispatchToProps$6)(DialogCreateFolder);
+const i18n$e = I18n.keyset("component.dialog-save-widget.view");
+class DialogCreateQLChart extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.onWorkbookApply = ({ name }) => {
+      const { workbookId, annotation } = this.props;
+      return this.props.sdk.charts.createWidget({
+        name,
+        workbookId,
+        data: this.props.data,
+        template: "ql",
+        annotation
+      });
+    };
+    this.onApply = async (key) => {
+      const data = await this.props.sdk.charts.createWidget({
+        key,
+        data: this.props.data,
+        template: "ql",
+        annotation: this.props.annotation
+      });
+      return data;
+    };
+    this.onError = (error) => {
+      if (isEntryAlreadyExists(error)) {
+        return {
+          inputError: i18n$e("label_entry-name-already-exists")
+        };
+      }
+      this.props.showToast({
+        title: i18n$e("toast_save-widget-failed"),
+        name: "DialogCreateWizardChartFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      this.props.onClose({
+        status: EntryDialogResolveStatus.Success,
+        data
+      });
+    };
+  }
+  render() {
+    const { workbookId } = this.props;
+    if (workbookId) {
+      return /* @__PURE__ */ jsx(
+        DialogCreateWorkbookEntry,
+        {
+          name: this.props.initName || i18n$e("label_widget-name-default"),
+          defaultName: i18n$e("label_widget-name-default"),
+          caption: i18n$e("section_caption"),
+          textButtonApply: i18n$e("button_apply"),
+          textButtonCancel: i18n$e("button_cancel"),
+          visible: this.props.visible,
+          onClose: this.onClose,
+          onApply: this.onWorkbookApply,
+          onSuccess: this.onSuccess,
+          onError: this.onError,
+          placeholder: i18n$e("label_placeholder")
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        withInput: true,
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        path: this.props.initDestination,
+        name: this.props.initName,
+        defaultName: i18n$e("label_widget-name-default"),
+        caption: i18n$e("section_caption"),
+        textButtonCancel: i18n$e("button_cancel"),
+        textButtonApply: i18n$e("button_apply"),
+        placeholder: i18n$e("label_placeholder")
+      }
+    );
+  }
+}
+const mapDispatchToProps$5 = {
+  showToast
+};
+const DialogCreateQLChart$1 = connect(null, mapDispatchToProps$5)(DialogCreateQLChart);
+const i18n$d = I18n.keyset("component.dialog-save-widget.view");
+class DialogCreateWizardChart extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.onWorkbookApply = async ({ name }) => {
+      const { workbookId, annotation } = this.props;
+      const data = await this.props.sdk.charts.createWidget({
+        name,
+        workbookId,
+        data: this.props.data,
+        template: "datalens",
+        annotation
+      });
+      return data;
+    };
+    this.onApply = async (key) => {
+      const data = await this.props.sdk.charts.createWidget({
+        key,
+        data: this.props.data,
+        template: "datalens",
+        annotation: this.props.annotation
+      });
+      return data;
+    };
+    this.onError = (error) => {
+      if (isEntryAlreadyExists(error)) {
+        return {
+          inputError: i18n$d("label_entry-name-already-exists")
+        };
+      }
+      this.props.showToast({
+        title: i18n$d("toast_save-widget-failed"),
+        name: "DialogCreateWizardChartFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      this.props.onClose({
+        status: EntryDialogResolveStatus.Success,
+        data
+      });
+    };
+  }
+  render() {
+    const { workbookId } = this.props;
+    if (workbookId) {
+      return /* @__PURE__ */ jsx(
+        DialogCreateWorkbookEntry,
+        {
+          name: this.props.initName || i18n$d("label_widget-name-default"),
+          defaultName: i18n$d("label_widget-name-default"),
+          caption: i18n$d("section_caption"),
+          textButtonApply: i18n$d("button_apply"),
+          textButtonCancel: i18n$d("button_cancel"),
+          visible: this.props.visible,
+          onClose: this.onClose,
+          onApply: this.onWorkbookApply,
+          onSuccess: this.onSuccess,
+          onError: this.onError,
+          placeholder: i18n$d("label_placeholder")
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        withInput: true,
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        path: this.props.initDestination,
+        name: this.props.initName,
+        defaultName: i18n$d("label_widget-name-default"),
+        caption: i18n$d("section_caption"),
+        textButtonCancel: i18n$d("button_cancel"),
+        textButtonApply: i18n$d("button_apply"),
+        placeholder: i18n$d("label_placeholder")
+      }
+    );
+  }
+}
+const mapDispatchToProps$4 = {
+  showToast
+};
+const DialogCreateWizardChart$1 = connect(null, mapDispatchToProps$4)(DialogCreateWizardChart);
+const i18n$c = I18n.keyset("component.dialog-delete-entry.view");
+const b$c = block("dl-dialog-delete-entry");
+class DialogDeleteEntry extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.onApply = async () => {
+      const { entry, cleanLock: cleanLock2, lockToken } = this.props;
+      await getSdk().sdk.mix.deleteEntry({
+        entryId: entry.entryId,
+        scope: entry.scope,
+        ...lockToken ? { lockToken } : {}
+      });
+      if (lockToken) {
+        cleanLock2();
+      }
+      const workbookId = entry?.workbookId;
+      return { entryId: entry.entryId, workbookId };
+    };
+    this.onError = (error) => {
+      this.props.showToast({
+        title: i18n$c("toast_delete-failed"),
+        name: "DialogDeleteEntryFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      const { entry } = this.props;
+      this.props.onClose({ status: EntryDialogResolveStatus.Success, data });
+      if (entry.scope === EntryScope.Connection) {
+        reachMetricaGoal(CounterName.Main, GoalId.ConnectionDeleteSubmit, { type: entry.type });
+      }
+    };
+  }
+  render() {
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        caption: i18n$c("section_caption"),
+        textButtonCancel: i18n$c("button_cancel"),
+        textButtonApply: i18n$c("button_delete"),
+        confirmButtonView: "outlined-danger",
+        children: Boolean(this.props.entry) && /* @__PURE__ */ jsxs("span", { className: b$c("entry"), children: [
+          /* @__PURE__ */ jsx("span", { className: b$c("entry-text"), children: i18n$c("label_delete") }),
+          /* @__PURE__ */ jsx(EntryTitle, { entry: this.props.entry, theme: "inline" })
+        ] })
+      }
+    );
+  }
+}
+const mapDispatchToProps$3 = {
+  showToast,
+  cleanLock
+};
+const mapStateToProps$2 = (state) => ({
+  lockToken: selectLockToken(state)
+});
+const DialogDeleteEntry$1 = connect(mapStateToProps$2, mapDispatchToProps$3)(DialogDeleteEntry);
+const b$b = block("dl-edit-favorites-alias");
+const i18n$b = I18n.keyset("component.dialog-edit-favorites-alias.view");
+const DialogEditFavoritesAlias = ({
+  entryId,
+  visible,
+  displayAlias,
+  onClose
+}) => {
+  const [text, setText] = React__default.useState(displayAlias ?? "");
+  const dispatch = useDispatch();
+  const onCloseDialog = () => {
+    onClose({ status: EntryDialogResolveStatus.Close });
+  };
+  const renameAlias = async (str) => {
+    let name = str;
+    if (name !== null) {
+      name = name.trim();
+      if (name === "") name = null;
+    }
+    if (name === displayAlias) {
+      onCloseDialog();
+    } else {
+      try {
+        await getSdk().sdk.us.renameFavorite({ entryId, name });
+        onClose({ status: EntryDialogResolveStatus.Success });
+      } catch (error) {
+        logger.logError("DialogEditFavoritesAlias: renameAlias failed", error);
+        dispatch(
+          showToast({
+            title: i18n$b("toast_rename-favorites-alias-failed"),
+            name: "DialogEditFavoritesAlias",
+            error,
+            withReport: true
+          })
+        );
+        onCloseDialog();
+      }
+    }
+  };
+  const onApplyDialog = () => {
+    renameAlias(text);
+  };
+  const onResetAlias = () => {
+    renameAlias(null);
+  };
+  const onChangeInput = (str) => {
+    setText(str);
+  };
+  const aliasExists = Boolean(displayAlias);
+  const caption = aliasExists ? i18n$b("caption_rename") : i18n$b("caption_add");
+  return /* @__PURE__ */ jsxs(
+    Dialog,
+    {
+      size: "s",
+      hasCloseButton: true,
+      open: visible,
+      onEnterKeyDown: onApplyDialog,
+      onClose: onCloseDialog,
+      children: [
+        /* @__PURE__ */ jsx(Dialog.Header, { caption }),
+        /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsx("div", { className: b$b("content"), children: /* @__PURE__ */ jsx(
+          TextInput,
+          {
+            autoFocus: true,
+            size: "l",
+            onUpdate: onChangeInput,
+            placeholder: i18n$b("label_placeholder"),
+            value: text,
+            hasClear: true
+          }
+        ) }) }),
+        /* @__PURE__ */ jsx(
+          Dialog.Footer,
+          {
+            onClickButtonCancel: onCloseDialog,
+            onClickButtonApply: onApplyDialog,
+            textButtonApply: i18n$b("button_apply"),
+            textButtonCancel: i18n$b("button_cancel"),
+            children: aliasExists && /* @__PURE__ */ jsx(Button, { view: "outlined-danger", size: "l", disabled: false, onClick: onResetAlias, children: i18n$b("button_delete") })
+          }
+        )
+      ]
+    }
+  );
+};
+const i18n$a = I18n.keyset("component.dialog-edit-warning.view");
+const b$a = block("dialog-dash-edit-warning");
+class DialogEditWarning extends React__default.PureComponent {
+  constructor() {
+    super(...arguments);
+    this.handlerShowClick = () => {
+      this.handlerClose();
+      this.props.onShowHistoryClick();
+    };
+    this.handlerEditEntryClick = () => {
+      this.handlerClose();
+      this.props.onEditClick();
+    };
+    this.handlerClose = () => this.props.onClose({ status: EntryDialogResolveStatus.Close });
+  }
+  render() {
+    const { visible, entryName = "" } = this.props;
+    return /* @__PURE__ */ jsx(
+      Dialog,
+      {
+        open: visible || false,
+        onClose: this.handlerClose,
+        qa: DialogDraftWarningQA.Dialog,
+        children: /* @__PURE__ */ jsxs("div", { className: b$a(), children: [
+          /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n$a("label_dash-warning-title") }),
+          /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+            Interpolate,
+            {
+              text: i18n$a("label_dash-warning-text", {
+                name: Utils.getEntryNameFromKey(entryName)
+              }),
+              matches: {
+                b(match) {
+                  return /* @__PURE__ */ jsx("span", { className: b$a("text-selected"), children: match });
+                }
+              }
+            }
+          ) }) }),
+          /* @__PURE__ */ jsxs(Dialog.Footer, { preset: "default", children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                view: "normal",
+                size: "l",
+                className: b$a("button"),
+                onClick: this.handlerEditEntryClick,
+                qa: DialogDraftWarningQA.EditButton,
+                children: i18n$a("button_edit")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                view: "action",
+                size: "l",
+                className: b$a("button"),
+                onClick: this.handlerShowClick,
+                children: i18n$a("button_show-in-history")
+              }
+            )
+          ] })
+        ] })
+      }
+    );
+  }
+}
+const mapStateToProps$1 = (state) => ({
+  entryName: state.dash.entry?.key
+});
+const DialogEditWarning$1 = connect(mapStateToProps$1)(DialogEditWarning);
+const i18n$9 = I18n.keyset("component.dialog-save-as-new-entry.view");
+class DialogEntrySaveAsNew extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.onWorkbookApply = async ({ name }) => {
+      const { workbookId, entryId } = this.props;
+      return this.props.onSaveAsNewCallback({ entryId, name, workbookId });
+    };
+    this.onApply = async (key) => {
+      const { entryId } = this.props;
+      return this.props.onSaveAsNewCallback({ entryId, key });
+    };
+    this.onError = (error) => {
+      if (isEntryAlreadyExists(error)) {
+        return {
+          inputError: i18n$9("label_entry-name-already-exists")
+        };
+      }
+      this.props.showToast({
+        title: i18n$9("toast_save-as-new-failed"),
+        name: "DialogEntrySaveAsNewFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Success, data });
+    };
+  }
+  render() {
+    const { workbookId, warningMessage } = this.props;
+    const name = `${this.props.initName} - ${i18n$9("label_copy")}`;
+    const defaultName = `${i18n$9("label_default-name")} - ${i18n$9("label_copy")}`;
+    if (workbookId) {
+      return /* @__PURE__ */ jsx(
+        DialogCreateWorkbookEntry,
+        {
+          name: name || defaultName,
+          defaultName,
+          caption: i18n$9("section_caption"),
+          textButtonApply: i18n$9("button_apply"),
+          textButtonCancel: i18n$9("button_cancel"),
+          visible: this.props.visible,
+          onClose: this.onClose,
+          onApply: this.onWorkbookApply,
+          onSuccess: this.onSuccess,
+          onError: this.onError,
+          placeholder: i18n$9("label_placeholder"),
+          warningMessage
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        withInput: true,
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        path: this.props.initDestination,
+        name,
+        defaultName,
+        caption: i18n$9("section_caption"),
+        textButtonCancel: i18n$9("button_cancel"),
+        textButtonApply: i18n$9("button_apply"),
+        placeholder: i18n$9("label_placeholder"),
+        warningMessage
+      }
+    );
+  }
+}
+const mapDispatchToProps$2 = {
+  showToast
+};
+const DialogEntrySaveAsNew$1 = connect(null, mapDispatchToProps$2)(DialogEntrySaveAsNew);
+const i18n$8 = I18n.keyset("component.dialog-set-actual-confirm.view");
+const b$9 = block("dialog-make-actual-confirm");
+class DialogMakeActualConfirm extends React__default.PureComponent {
+  constructor() {
+    super(...arguments);
+    this.handlerShowClick = () => this.props.onConfirm();
+    this.handlerClose = () => this.props.onClose({ status: EntryDialogResolveStatus.Close });
+  }
+  componentDidUpdate() {
+    if (this.props.updatingStatus === DashUpdateStatus.Successed) {
+      this.handlerClose();
+    }
+  }
+  render() {
+    const { visible, updatingStatus } = this.props;
+    return /* @__PURE__ */ jsx(Dialog, { open: visible || false, onClose: this.handlerClose, children: /* @__PURE__ */ jsxs("div", { className: b$9(), children: [
+      /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n$8("label_title") }),
+      /* @__PURE__ */ jsxs(Dialog.Body, { className: b$9("body"), children: [
+        /* @__PURE__ */ jsx("div", { className: b$9("icon"), children: /* @__PURE__ */ jsx(Icon, { data: TriangleExclamationFill, size: 32 }) }),
+        /* @__PURE__ */ jsx("div", { className: b$9("message"), children: i18n$8("label_text") })
+      ] }),
+      /* @__PURE__ */ jsx(Dialog.Footer, { preset: "default", children: /* @__PURE__ */ jsxs("div", { className: b$9("controls"), children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            view: "flat",
+            size: "l",
+            className: b$9("button"),
+            onClick: this.handlerClose,
+            children: i18n$8("button_cancel")
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            view: "action",
+            size: "l",
+            className: b$9("button"),
+            onClick: this.handlerShowClick,
+            loading: updatingStatus === DashUpdateStatus.Loading,
+            children: i18n$8("button_confirm")
+          }
+        )
+      ] }) })
+    ] }) });
+  }
+}
+const mapStateToProps = (state) => ({
+  entry: state.dash.entry,
+  updatingStatus: state.dash.updateStatus
+});
+const DialogMakeActualConfirm$1 = connect(mapStateToProps)(DialogMakeActualConfirm);
+const DialogMigrateToWorkbook = ({
+  entryId,
+  visible,
+  onClose
+}) => {
+  return /* @__PURE__ */ jsx(
+    SelectMigrationToWorkbookDialog,
+    {
+      open: visible,
+      entryId,
+      onSuccess: () => {
+        onClose({ status: EntryDialogResolveStatus.Success });
+      },
+      onClose: () => {
+        onClose({ status: EntryDialogResolveStatus.Close });
+      }
+    }
+  );
+};
+const i18n$7 = I18n.keyset("component.dialog-move-entry.view");
+class DialogMoveEntry extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.onApply = async (key) => {
+      const result = await getSdk().sdk.us.moveEntry({
+        entryId: this.props.entryId,
+        destination: key
+      });
+      return {
+        entryId: this.props.entryId,
+        destination: key,
+        result
+      };
+    };
+    this.onError = (error) => {
+      const title = isEntryAlreadyExists(error) ? i18n$7("label_entry-name-already-exists") : i18n$7("toast_move-failed");
+      this.props.showToast({
+        title,
+        name: "DialogMoveEntryFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Success, data });
+    };
+  }
+  render() {
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        withInput: false,
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        path: this.props.initDestination,
+        inactiveEntryKeys: this.props.inactiveEntryKeys,
+        caption: i18n$7("section_caption"),
+        textButtonCancel: i18n$7("button_cancel"),
+        textButtonApply: i18n$7("button_apply")
+      }
+    );
+  }
+}
+const mapDispatchToProps$1 = {
+  showToast
+};
+const DialogMoveEntry$1 = connect(null, mapDispatchToProps$1)(DialogMoveEntry);
+const i18n$6 = I18n.keyset("component.dialog-rename-entry.view");
+class DialogRenameEntry extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      visible: this.props.visible,
+      name: this.props.initName,
+      inputError: false
+    };
+    this.onChangeInput = (value) => {
+      this.setState({ name: value, inputError: false });
+    };
+    this.onApply = async () => {
+      const data = await getSdk().sdk.us.renameEntry({
+        entryId: this.props.entryId,
+        name: this.state.name.trim()
+      });
+      return data;
+    };
+    this.onError = (error) => {
+      if (isEntryAlreadyExists(error)) {
+        this.setState({ inputError: i18n$6("label_entry-name-already-exists") });
+        return null;
+      }
+      this.props.showToast({
+        title: i18n$6("toast_rename-failed"),
+        name: "DialogRenameEntryFailed",
+        error,
+        withReport: true
+      });
+      return null;
+    };
+    this.onClose = () => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Close });
+    };
+    this.onSuccess = (data) => {
+      this.props.onClose({ status: EntryDialogResolveStatus.Success, data });
+    };
+  }
+  static getDerivedStateFromProps(props, state) {
+    if (props.visible !== state.visible) {
+      return {
+        visible: props.visible,
+        name: props.initName,
+        inputError: false
+      };
+    }
+    return null;
+  }
+  render() {
+    return /* @__PURE__ */ jsx(
+      EntryDialogBase,
+      {
+        onClose: this.onClose,
+        onApply: this.onApply,
+        onSuccess: this.onSuccess,
+        onError: this.onError,
+        visible: this.props.visible,
+        caption: i18n$6("section_caption"),
+        textButtonCancel: i18n$6("button_cancel"),
+        textButtonApply: i18n$6("button_apply"),
+        initialFocus: 0,
+        children: /* @__PURE__ */ jsx(
+          TextInput,
+          {
+            autoFocus: true,
+            size: "l",
+            onUpdate: this.onChangeInput,
+            placeholder: i18n$6("label_placeholder"),
+            value: this.state.name,
+            hasClear: true,
+            error: this.state.inputError
+          }
+        )
+      }
+    );
+  }
+}
+const mapDispatchToProps = {
+  showToast
+};
+const DialogRenameEntry$1 = connect(null, mapDispatchToProps)(DialogRenameEntry);
+const DialogShareEntry = (props) => {
+  const { DialogShare } = registry.common.components.getAll();
+  const { sdk: _sdk, onClose, ...dialogShareProps } = props;
+  const handleOnClose = React__default.useCallback(
+    () => onClose({ status: EntryDialogResolveStatus.Close }),
+    []
+  );
+  return /* @__PURE__ */ jsx(DialogShare, { ...dialogShareProps, onClose: handleOnClose });
+};
+const b$8 = block("dl-dialog-public-author-section");
+const i18n$5 = I18n.keyset("component.dialog-switch-public.view");
+function AuthorSection(props) {
+  const { className, authorData, disabled, onChange, scope, validationErrors } = props;
+  return /* @__PURE__ */ jsxs("div", { className: b$8(null, className), children: [
+    /* @__PURE__ */ jsx("div", { className: b$8("title"), children: i18n$5("section_author") }),
+    /* @__PURE__ */ jsx("div", { className: b$8("description"), children: i18n$5("label_author-description", { subject: i18n$5(`label_author-subject-${scope}`) }) }),
+    /* @__PURE__ */ jsxs("div", { className: b$8("form"), children: [
+      /* @__PURE__ */ jsx(FormRow, { label: i18n$5("label_author-text"), className: b$8("form-row"), children: /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          error: validationErrors.text ?? false,
+          value: authorData.text,
+          disabled,
+          onUpdate: (value) => onChange({ text: value })
+        }
+      ) }),
+      /* @__PURE__ */ jsx(FormRow, { label: i18n$5("label_author-link"), className: b$8("form-row"), children: /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          error: validationErrors.link ?? false,
+          value: authorData.link,
+          disabled,
+          onUpdate: (value) => onChange({ link: value })
+        }
+      ) })
+    ] })
+  ] });
+}
+const b$7 = block("dl-dialog-public-error");
+function ContentError({ className, buttonText, errorText, errorDescription, onClick }) {
+  return /* @__PURE__ */ jsxs("div", { className: b$7(null, className), children: [
+    /* @__PURE__ */ jsx("div", { className: b$7("error-text"), children: errorText }),
+    errorDescription && /* @__PURE__ */ jsx("div", { className: b$7("error-text"), children: errorDescription }),
+    /* @__PURE__ */ jsx(Button, { view: "action", size: "l", onClick, children: buttonText })
+  ] });
+}
+const b$6 = block("dl-dialog-public-loader");
+function ContentLoader({ className }) {
+  return /* @__PURE__ */ jsx("div", { className: b$6(null, className), children: /* @__PURE__ */ jsx(Loader, { size: "m" }) });
+}
+const b$5 = block("dl-dialog-public-alert-tooltip");
+const defaultTooltipPlacement = ["left", "bottom", "top"];
+function AlertTooltip({ className, text, tooltipPlacement: tooltipPlacement2 }) {
+  const placement = tooltipPlacement2 || defaultTooltipPlacement;
+  return /* @__PURE__ */ jsx("div", { className: b$5(null, className), children: /* @__PURE__ */ jsx(Popover, { content: text, placement, children: /* @__PURE__ */ jsx(Icon, { data: TriangleExclamation, className: b$5("icon") }) }) });
+}
+const b$4 = block("dl-dialog-public-shared-link");
+const i18n$4 = I18n.keyset("component.dialog-switch-public.view");
+function SharedLink({ className, entry, disabled }) {
+  const text = disabled ? i18n$4("label_placeholder-publishing-not-enabled") : `${DL.ENDPOINTS.public || "https://stub"}/${entry.entryId}`;
+  const onCopyLink = () => {
+    toaster.add({
+      name: "successSharedLinkCopied",
+      theme: "success",
+      title: i18n$4("toast_link-copied")
+    });
+  };
+  return /* @__PURE__ */ jsxs("div", { className: b$4(null, className), children: [
+    /* @__PURE__ */ jsx("div", { className: b$4("input-place"), children: /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        className: b$4("input-link", { active: !disabled }),
+        disabled: true,
+        value: text
+      }
+    ) }),
+    !disabled && /* @__PURE__ */ jsx("div", { className: b$4("clipboard-button"), children: /* @__PURE__ */ jsx(CopyToClipboard, { text, timeout: CLIPBOARD_TIMEOUT, onCopy: onCopyLink, children: () => /* @__PURE__ */ jsx(Button, { view: "outlined", children: i18n$4("button_copy") }) }) })
+  ] });
+}
+const b$3 = block("dl-dialog-public-current-entry");
+const i18n$3 = I18n.keyset("component.dialog-switch-public.view");
+const tooltipPlacement = ["bottom", "top", "left", "right"];
+function CurrentEntrySection({
+  entry,
+  className,
+  checked,
+  onChange,
+  progress,
+  disabled,
+  tooltip
+}) {
+  function onChangeTumbler() {
+    if (!progress) {
+      onChange();
+    }
+  }
+  return /* @__PURE__ */ jsxs("div", { className: b$3(null, className), children: [
+    /* @__PURE__ */ jsx("div", { className: b$3("title"), children: i18n$3("section_current-entry") }),
+    /* @__PURE__ */ jsxs("div", { className: b$3("entry-line"), children: [
+      /* @__PURE__ */ jsxs("div", { className: b$3("current-entry"), children: [
+        /* @__PURE__ */ jsx(EntryIcon, { entry, width: 20, height: 20, className: b$3("entry-icon") }),
+        /* @__PURE__ */ jsx(
+          Link,
+          {
+            view: "primary",
+            target: "_blank",
+            className: b$3("entry-name"),
+            title: entry.key,
+            href: navigateHelper_default.redirectUrlSwitcher(entry),
+            children: getEntryNameByKey({ key: entry.key })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: b$3("other"), children: [
+        Boolean(tooltip) && /* @__PURE__ */ jsx(
+          AlertTooltip,
+          {
+            className: b$3("alert"),
+            text: tooltip,
+            tooltipPlacement
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Switch,
+          {
+            size: "m",
+            disabled,
+            checked,
+            onUpdate: onChangeTumbler
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(SharedLink, { className: b$3("shared-link"), entry, disabled: !checked }) })
+  ] });
+}
+function getInitState() {
+  return {
+    resolve: null,
+    visible: false,
+    props: {}
+  };
+}
+const withPromiseOpen = (Component) => class WithPromiseOpen extends React__default.Component {
+  state = getInitState();
+  // public via ref
+  open(props = {}) {
+    return new Promise((resolve) => {
+      this.setState({
+        resolve,
+        props,
+        visible: true
+      });
+    });
+  }
+  _onClose = (data) => {
+    const { resolve } = this.state;
+    this.setState(getInitState());
+    resolve(data);
+  };
+  render() {
+    const { visible, props } = this.state;
+    return visible ? /* @__PURE__ */ React__default.createElement(Component, { ...props, visible, onClose: this._onClose }) : null;
+  }
+};
+const RESOLVE_STATUS = {
+  CLOSE: "close",
+  APPLY: "apply"
+};
+const DIALOG_STATUS = {
+  LOADING: "loading",
+  SUCCESS: "success",
+  FAILED: "failed"
+};
+const b$2 = block("dl-public-alert-dialog");
+const i18n$2 = I18n.keyset("component.dialog-switch-public.view");
+function DialogAlert({ visible, onClose, publish, many }) {
+  function onCloseDialog() {
+    onClose({ status: RESOLVE_STATUS.CLOSE });
+  }
+  function onApplyDialog() {
+    onClose({ status: RESOLVE_STATUS.APPLY });
+  }
+  let caption;
+  let text;
+  if (many) {
+    caption = publish ? i18n$2("section_alert-publish-title-many") : i18n$2("section_alert-unpublish-title-many");
+    text = publish ? i18n$2("label_alert-publish-text-many") : i18n$2("label_alert-unpublish-text-many");
+  } else {
+    caption = publish ? i18n$2("section_alert-publish-title") : i18n$2("section_alert-unpublish-title");
+    text = publish ? i18n$2("label_alert-publish-text") : i18n$2("label_alert-unpublish-text");
+  }
+  return /* @__PURE__ */ jsx(Dialog, { hasCloseButton: false, open: visible, onClose: onCloseDialog, children: /* @__PURE__ */ jsxs("div", { className: b$2(), children: [
+    /* @__PURE__ */ jsx(Dialog.Header, { caption }),
+    /* @__PURE__ */ jsx(Dialog.Body, { className: b$2("body"), children: text }),
+    /* @__PURE__ */ jsx(
+      Dialog.Footer,
+      {
+        onClickButtonCancel: onCloseDialog,
+        onClickButtonApply: onApplyDialog,
+        textButtonApply: i18n$2("button_continue"),
+        textButtonCancel: i18n$2("button_cancel")
+      }
+    )
+  ] }) });
+}
+const DialogAlert$1 = withPromiseOpen(DialogAlert);
+const b$1 = block("dl-dialog-public-relations-list");
+const i18n$1 = I18n.keyset("component.dialog-switch-public.view");
+const groupsOrder = ["widget", "dataset", "connection"];
+function RelationsList({ className, groups, progress, onChange }) {
+  function onChangeTumbler(entry) {
+    if (!progress) {
+      onChange({
+        relations: [entry],
+        nextChecked: !entry.checked
+      });
+    }
+  }
+  function onChangeAll({ nextChecked, group }) {
+    if (!progress) {
+      onChange({
+        relations: group.filter((entry) => !entry.disabled),
+        nextChecked
+      });
+    }
+  }
+  const renderRightSection = (entry) => {
+    return /* @__PURE__ */ jsxs("div", { className: b$1("right-section"), children: [
+      Boolean(entry.tooltip) && /* @__PURE__ */ jsx(AlertTooltip, { className: b$1("alert"), text: entry.tooltip }),
+      /* @__PURE__ */ jsx(
+        Switch,
+        {
+          size: "m",
+          checked: entry.checked,
+          disabled: entry.disabled,
+          onUpdate: () => onChangeTumbler(entry)
+        }
+      )
+    ] });
+  };
+  function renderGroup(group, relationScope) {
+    const allDisabled = group.every((entry) => entry.disabled);
+    const btnDisabled = progress || allDisabled;
+    let nextChecked = !group.filter((entry) => !entry.disabled).every((entry) => entry.checked);
+    if (allDisabled) {
+      nextChecked = !group.every((entry) => entry.checked);
+    }
+    const btnText = nextChecked ? i18n$1("button_enable-all") : i18n$1("button_disable-all");
+    return /* @__PURE__ */ jsxs("div", { className: b$1("group"), children: [
+      /* @__PURE__ */ jsxs("div", { className: b$1("group-title"), children: [
+        /* @__PURE__ */ jsx("div", { className: b$1("group-title-text"), children: i18n$1(`section_${relationScope}-relations`) }),
+        group.length > 1 && /* @__PURE__ */ jsx(
+          Button,
+          {
+            view: "outlined",
+            disabled: btnDisabled,
+            onClick: () => onChangeAll({ nextChecked, group }),
+            children: btnText
+          }
+        )
+      ] }),
+      group.map((entry) => /* @__PURE__ */ jsx(
+        EntryRow,
+        {
+          entry,
+          rightSectionSlot: renderRightSection(entry),
+          enableHover: true
+        },
+        entry.entryId
+      ))
+    ] }, relationScope);
+  }
+  const isGroupsExist = Object.values(groups).some((group) => group.length);
+  return /* @__PURE__ */ jsxs("div", { className: b$1(null, className), children: [
+    isGroupsExist && /* @__PURE__ */ jsx("div", { className: b$1("main-title-text"), children: i18n$1(`section_object-relations`) }),
+    groupsOrder.map((relationScope) => {
+      const group = groups[relationScope];
+      return Array.isArray(group) ? renderGroup(group, relationScope) : null;
+    })
+  ] });
+}
+const DIALOG_PUBLIC_SET_LOADING = /* @__PURE__ */ Symbol("dialogPublic/SET_LOADING");
+const DIALOG_PUBLIC_SET_REFETCH = /* @__PURE__ */ Symbol("dialogPublic/SET_REFETCH");
+const DIALOG_PUBLIC_SET_APPLY = /* @__PURE__ */ Symbol("dialogPublic/SET_APPLY");
+const DIALOG_PUBLIC_SET_FAILED = /* @__PURE__ */ Symbol("dialogPublic/SET_FAILED");
+const DIALOG_PUBLIC_SET_SUCCESS = /* @__PURE__ */ Symbol("dialogPublic/SET_SUCCESS");
+const DIALOG_PUBLIC_SET_PUBLISH_UNPUBLISH_ONCE = /* @__PURE__ */ Symbol(
+  "dialogPublic/SET_PUBLISH_UNPUBLISH_ONCE"
+);
+const DIALOG_PUBLIC_CHANGE_RELATIONS_ENTRIES = /* @__PURE__ */ Symbol(
+  "dialogPublic/CHANGE_RELATIONS_ENTRIES"
+);
+const DIALOG_PUBLIC_CHANGE_STATE = /* @__PURE__ */ Symbol("dialogPublic/CHANGE_STATE");
+const DIALOG_PUBLIC_CHANGE_ENTRY_AUTHOR = /* @__PURE__ */ Symbol("dialogPublic/CHANGE_ENTRY_AUTHOR");
+const isValidPublishLink = (link) => {
+  const validLinkRe = /^(http(s)?:\/\/|tel:|mailto:)/g;
+  if (link) {
+    return validLinkRe.test(link);
+  }
+  return true;
+};
+function getTextNoPermission() {
+  return i18n$m("component.dialog-switch-public.view", "label_no-permission-alert", {
+    permission: i18n$m("component.permission-select.view", "field_admin")
+  });
+}
+function formGroups(normalizedRelations) {
+  const relationsArray = Object.values(normalizedRelations);
+  return groupEntitiesByScope(relationsArray);
+}
+function isPermanentDisabledEntry(entry) {
+  return !entry?.permissions?.admin || Boolean(entry.lockPublication);
+}
+function normalizeRelations(relations, entry) {
+  let allDisabled = !entry?.permissions?.admin;
+  const currentEntryChecked = entry.public;
+  const someEntryLocked = relations.some(({ lockPublication }) => Boolean(lockPublication));
+  const normalized = relations.reduce(
+    (acc, relationEntry) => {
+      let tooltip = "";
+      const hasAdminPermission = relationEntry?.permissions?.admin;
+      const checked = relationEntry.public;
+      const disabled = isPermanentDisabledEntry(relationEntry) || // We do not allow you to publish anything if there is an invalid dataset
+      // CHARTS-3401
+      someEntryLocked && !checked;
+      if (!currentEntryChecked && disabled) {
+        allDisabled = true;
+      }
+      if (relationEntry.lockPublication) {
+        tooltip = relationEntry.lockPublicationReason || i18n$m("component.dialog-switch-public.view", "label_dataset-deny-publish");
+      }
+      if (!hasAdminPermission) {
+        tooltip = getTextNoPermission();
+      }
+      return {
+        ...acc,
+        [relationEntry.entryId]: {
+          ...relationEntry,
+          tooltip,
+          checked,
+          disabled
+        }
+      };
+    },
+    {}
+  );
+  if (allDisabled) {
+    return Object.keys(normalized).reduce(
+      (acc, entryId) => {
+        return {
+          ...acc,
+          [entryId]: {
+            ...normalized[entryId],
+            disabled: true
+          }
+        };
+      },
+      {}
+    );
+  }
+  return normalized;
+}
+function getCurrentEntryDisabled(entry, normalizedRelations) {
+  if (!entry?.permissions?.admin) {
+    return {
+      currentEntryDisabled: true,
+      currentEntryTooltip: getTextNoPermission()
+    };
+  }
+  if (Object.values(normalizedRelations).some(({ disabled }) => disabled)) {
+    return {
+      currentEntryDisabled: !entry.public,
+      currentEntryTooltip: i18n$m(
+        "component.dialog-switch-public.view",
+        "label_some-entries-not-ready"
+      ),
+      hasLockedEntries: true
+    };
+  }
+  return {
+    currentEntryDisabled: false,
+    currentEntryTooltip: ""
+  };
+}
+function hasPublishChanges(state) {
+  const { entry, relations, currentEntryChecked } = state;
+  if (entry.public !== currentEntryChecked) {
+    return true;
+  }
+  return Object.values(relations).some((entry2) => {
+    return entry2.public !== entry2.checked;
+  });
+}
+function hasAuthorChanges(state) {
+  const { entry } = state;
+  const entryAuthorData = entry?.unversionedData?.publicAuthor || {
+    link: "",
+    text: ""
+  };
+  return entryAuthorData.link !== state.entryAuthor.link.trim() || entryAuthorData.text !== state.entryAuthor.text.trim();
+}
+function getPublicationEntries(state) {
+  const { entry, currentEntryChecked, relations } = state;
+  const entries = [
+    {
+      entryId: entry.entryId,
+      scope: entry.scope,
+      publish: currentEntryChecked
+    }
+  ];
+  Object.values(relations).forEach((relationEntry) => {
+    if (relationEntry.public !== relationEntry.checked) {
+      entries.push({
+        entryId: relationEntry.entryId,
+        scope: relationEntry.scope,
+        publish: Boolean(relationEntry.checked)
+      });
+    }
+  });
+  return entries;
+}
+function isValid(state) {
+  return Object.entries(state.validationErrors).every(([_, value]) => value === null);
+}
+const getInitialState = (data) => {
+  const entryAuthorData = data.entry?.unversionedData?.publicAuthor || {
+    link: "",
+    text: ""
+  };
+  return {
+    ...data,
+    onClose: data.onClose,
+    entry: data.entry,
+    status: DIALOG_STATUS.LOADING,
+    progress: false,
+    refetchCounter: 0,
+    applyCounter: 0,
+    currentEntryChecked: Boolean(data.entry?.public),
+    relations: {},
+    groups: {},
+    onceChangePublish: false,
+    onceChangeUnpublish: false,
+    currentEntryDisabled: true,
+    currentEntryTooltip: "",
+    entryAuthor: {
+      link: entryAuthorData?.link || "",
+      text: entryAuthorData?.text || ""
+    },
+    validationErrors: {
+      link: null,
+      text: null
+    },
+    error: {
+      title: ""
+    },
+    hasLockedEntries: false
+  };
+};
+const reducer = (state, action) => {
+  switch (action.type) {
+    case DIALOG_PUBLIC_SET_LOADING:
+      return {
+        ...state,
+        status: DIALOG_STATUS.LOADING,
+        progress: true,
+        error: {
+          title: ""
+        }
+      };
+    case DIALOG_PUBLIC_SET_SUCCESS:
+      return {
+        ...state,
+        status: DIALOG_STATUS.SUCCESS,
+        progress: false
+      };
+    case DIALOG_PUBLIC_SET_FAILED:
+      return {
+        ...state,
+        status: DIALOG_STATUS.FAILED,
+        progress: false,
+        error: action.payload?.error || { title: "" }
+      };
+    case DIALOG_PUBLIC_SET_REFETCH:
+      return {
+        ...getInitialState(state),
+        refetchCounter: state.refetchCounter + 1
+      };
+    case DIALOG_PUBLIC_SET_APPLY: {
+      return {
+        ...state,
+        applyCounter: state.applyCounter + 1
+      };
+    }
+    case DIALOG_PUBLIC_CHANGE_STATE:
+      return {
+        ...state,
+        ...action.payload
+      };
+    case DIALOG_PUBLIC_SET_PUBLISH_UNPUBLISH_ONCE: {
+      let relations = state.relations;
+      let groups = state.groups;
+      const nextChecked = !state.currentEntryChecked;
+      let needUpdate = false;
+      const relationsCandidate = Object.keys(relations).reduce((acc, entryId) => {
+        let entry = relations[entryId];
+        if (!entry.disabled && entry.checked !== nextChecked) {
+          needUpdate = true;
+          entry = {
+            ...entry,
+            checked: nextChecked
+          };
+        }
+        return {
+          ...acc,
+          [entryId]: entry
+        };
+      }, {});
+      if (needUpdate) {
+        relations = relationsCandidate;
+        groups = formGroups(relationsCandidate);
+      }
+      return {
+        ...state,
+        relations,
+        groups,
+        currentEntryChecked: nextChecked,
+        ...action.payload
+      };
+    }
+    case DIALOG_PUBLIC_CHANGE_RELATIONS_ENTRIES: {
+      const { relations, nextChecked, ...restState } = action.payload;
+      const newRelations = relations.map(({ entryId }) => entryId).reduce((acc, entryId) => {
+        return {
+          ...acc,
+          [entryId]: {
+            ...state.relations[entryId],
+            checked: nextChecked
+          }
+        };
+      }, {});
+      const newStateRelations = {
+        ...state.relations,
+        ...newRelations
+      };
+      return {
+        ...state,
+        relations: newStateRelations,
+        groups: formGroups(newStateRelations),
+        ...restState
+      };
+    }
+    case DIALOG_PUBLIC_CHANGE_ENTRY_AUTHOR: {
+      const entryAuthor = {
+        ...state.entryAuthor
+      };
+      const validationErrors = {
+        ...state.validationErrors
+      };
+      if (action.payload.link !== void 0) {
+        entryAuthor.link = action.payload.link;
+        if (isValidPublishLink(entryAuthor.link)) {
+          validationErrors.link = null;
+        } else {
+          validationErrors.link = i18n$m(
+            "component.dialog-switch-public.view",
+            "label_author-link-error"
+          );
+        }
+      }
+      if (action.payload.text !== void 0) {
+        entryAuthor.text = action.payload.text;
+      }
+      return {
+        ...state,
+        validationErrors,
+        entryAuthor
+      };
+    }
+    default:
+      return state;
+  }
+};
+const useDialogPublicState = ({
+  entry: propsEntry,
+  onClose
+}) => {
+  const refMounted = useRefMounted();
+  const [state, dispatch] = React__default.useReducer(
+    reducer,
+    getInitialState({
+      entry: {
+        ...propsEntry,
+        tooltip: "",
+        disabled: false
+      },
+      onClose
+    })
+  );
+  const dispatchStore = useDispatch();
+  React__default.useEffect(() => {
+    async function init() {
+      dispatch({ type: DIALOG_PUBLIC_SET_LOADING });
+      try {
+        const entry = await getSdk().sdk.us.getEntry({
+          entryId: propsEntry.entryId,
+          includePermissionsInfo: true,
+          includeDlComponentUiData: true
+        });
+        const relations = await getSdk().sdk.mix.getPublicationPreview({
+          entryId: entry.entryId,
+          workbookId: entry.workbookId
+        });
+        const extendedEntry = {
+          ...entry,
+          tooltip: "",
+          disabled: false
+        };
+        if (refMounted.current) {
+          const normalizedRelations = normalizeRelations(relations, extendedEntry);
+          const { currentEntryDisabled, currentEntryTooltip, hasLockedEntries } = getCurrentEntryDisabled(extendedEntry, normalizedRelations);
+          const entryAuthor = { text: "", link: "" };
+          if (entry.unversionedData) {
+            const unversionedData = entry.unversionedData;
+            if (unversionedData.publicAuthor) {
+              entryAuthor.text = unversionedData.publicAuthor.text;
+              entryAuthor.link = unversionedData.publicAuthor.link;
+            }
+          }
+          dispatch({
+            type: DIALOG_PUBLIC_CHANGE_STATE,
+            payload: {
+              ...state,
+              status: DIALOG_STATUS.SUCCESS,
+              entry: extendedEntry,
+              currentEntryChecked: entry.public,
+              relations: normalizedRelations,
+              groups: formGroups(normalizedRelations),
+              progress: false,
+              currentEntryDisabled,
+              currentEntryTooltip,
+              entryAuthor,
+              hasLockedEntries: Boolean(hasLockedEntries)
+            }
+          });
+        }
+      } catch (error) {
+        logger.logError("DialogSwitchPublic: init failed", error);
+        if (refMounted.current) {
+          const apiError = error;
+          const errorAction = {
+            type: DIALOG_PUBLIC_SET_FAILED
+          };
+          const parsedDetails = Utils.getErrorDetails(apiError);
+          const errorDetails = parsedDetails?.details;
+          if (errorDetails?.title) {
+            errorAction.payload = {
+              error: {
+                title: errorDetails.title,
+                description: errorDetails.description
+              }
+            };
+          }
+          dispatch(errorAction);
+          dispatchStore(
+            showToast({
+              title: i18n$m(
+                "component.dialog-switch-public.view",
+                "toast_get-publication-preview-failed"
+              ),
+              name: "failedGetPublicationPreview",
+              error: apiError
+            })
+          );
+        }
+      }
+    }
+    init();
+  }, [state.refetchCounter]);
+  React__default.useEffect(() => {
+    if (state.applyCounter) {
+      dispatch({
+        type: DIALOG_PUBLIC_CHANGE_STATE,
+        payload: {
+          ...state,
+          progress: true
+        }
+      });
+      const entries = getPublicationEntries(state);
+      getSdk().sdk.mix.switchPublicationStatus({
+        entries,
+        mainEntry: {
+          entryId: propsEntry.entryId,
+          unversionedData: {
+            publicAuthor: {
+              text: state.entryAuthor.text.trim(),
+              link: state.entryAuthor.link.trim()
+            }
+          }
+        },
+        workbookId: propsEntry.workbookId
+      }).then(() => {
+        reachMetricaGoal(CounterName.Main, GoalId.DashboardPublicAccessSubmit);
+        toaster.add({
+          name: "successSwitchPublicationStatus",
+          theme: "success",
+          title: i18n$m(
+            "component.dialog-switch-public.view",
+            "toast_switch-publication-status-success"
+          )
+        });
+        if (refMounted.current) {
+          dispatch({
+            type: DIALOG_PUBLIC_SET_SUCCESS
+          });
+          onClose("success", state.currentEntryChecked);
+        }
+      }).catch((error) => {
+        logger.logError("DialogSwitchPublic: switchPublicationStatus failed", error);
+        if (refMounted.current) {
+          dispatch({
+            type: DIALOG_PUBLIC_SET_FAILED
+          });
+          dispatchStore(
+            showToast({
+              title: i18n$m(
+                "component.dialog-switch-public.view",
+                "toast_switch-publication-status-failed"
+              ),
+              name: "failedSwitchPublicationStatus",
+              error
+            })
+          );
+        }
+      });
+    }
+  }, [state.applyCounter]);
+  const refetch = React__default.useCallback(() => {
+    dispatch({ type: DIALOG_PUBLIC_SET_REFETCH });
+  }, []);
+  const apply = React__default.useCallback(() => {
+    dispatch({ type: DIALOG_PUBLIC_SET_APPLY });
+  }, []);
+  const setState = React__default.useCallback((payload) => {
+    dispatch({ type: DIALOG_PUBLIC_CHANGE_STATE, payload });
+  }, []);
+  const dispatchAction = React__default.useCallback((type, payload) => {
+    dispatch({ type, payload });
+  }, []);
+  return {
+    state,
+    disableApply: !hasPublishChanges(state) && !hasAuthorChanges(state) || !isValid(state),
+    refetch,
+    apply,
+    dispatchAction,
+    setState
+  };
+};
+const b = block("dl-dialog-make-public");
+const i18n = I18n.keyset("component.dialog-switch-public.view");
+function DialogPublic({ onClose, visible, entry: propsEntry }) {
+  const alertDialogRef = React__default.useRef(null);
+  const { state, apply, refetch, disableApply, dispatchAction } = useDialogPublicState({
+    entry: propsEntry,
+    onClose
+  });
+  async function onChangeCurrentEntry() {
+    const newState = {};
+    if (!state.onceChangeUnpublish && state.entry.public && state.currentEntryChecked) {
+      const result = await alertDialogRef.current?.open({ publish: false });
+      if (result.status === RESOLVE_STATUS.CLOSE) {
+        return;
+      }
+      newState.onceChangeUnpublish = true;
+    } else if (!state.onceChangePublish && !state.entry.public && !state.currentEntryChecked) {
+      const result = await alertDialogRef.current?.open({ publish: true });
+      if (result.status === RESOLVE_STATUS.CLOSE) {
+        return;
+      }
+      newState.onceChangePublish = true;
+    }
+    dispatchAction(DIALOG_PUBLIC_SET_PUBLISH_UNPUBLISH_ONCE, newState);
+  }
+  async function onChangeRelationsEntries({
+    relations,
+    nextChecked
+  }) {
+    const newState = {
+      relations,
+      nextChecked
+    };
+    if (!state.onceChangeUnpublish && !nextChecked && relations.some((relationEntry) => relationEntry.public && relationEntry.checked)) {
+      const result = await alertDialogRef.current.open({
+        publish: false,
+        many: relations.length > 1
+      });
+      if (result.status === RESOLVE_STATUS.CLOSE) {
+        return;
+      }
+      newState.onceChangeUnpublish = true;
+    } else if (!state.onceChangePublish && nextChecked && relations.some((relationEntry) => !relationEntry.public && !relationEntry.checked)) {
+      const result = await alertDialogRef.current.open({
+        publish: true,
+        many: relations.length > 1
+      });
+      if (result.status === RESOLVE_STATUS.CLOSE) {
+        return;
+      }
+      newState.onceChangePublish = true;
+    }
+    dispatchAction(DIALOG_PUBLIC_CHANGE_RELATIONS_ENTRIES, newState);
+  }
+  async function onChangeEntryAuthor({ link, text }) {
+    dispatchAction(DIALOG_PUBLIC_CHANGE_ENTRY_AUTHOR, {
+      link,
+      text
+    });
+  }
+  function renderContent() {
+    const scope = state.entry.scope;
+    const attentionMessage = state.hasLockedEntries ? i18n("md_label_unavaible-publication-attention", {
+      link: formDocsEndpointDL("/concepts/datalens-public#rules")
+    }) : i18n("label_main-attention", {
+      subject: i18n(`label_main-subject-${scope}`)
+    });
+    const icon = state.hasLockedEntries ? void 0 : /* @__PURE__ */ jsx("div", { className: b("attention-icon"), children: /* @__PURE__ */ jsx(TriangleExclamationFill, { width: 16, height: 16 }) });
+    return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        Alert,
+        {
+          theme: "danger",
+          message: /* @__PURE__ */ jsx(YfmWrapper, { content: attentionMessage, setByInnerHtml: true }),
+          icon
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        CurrentEntrySection,
+        {
+          className: b("current-entry"),
+          entry: state.entry,
+          checked: state.currentEntryChecked,
+          onChange: onChangeCurrentEntry,
+          progress: state.progress,
+          disabled: state.currentEntryDisabled,
+          tooltip: state.currentEntryTooltip
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        AuthorSection,
+        {
+          validationErrors: state.validationErrors,
+          className: b("author-section"),
+          authorData: state.entryAuthor,
+          onChange: onChangeEntryAuthor,
+          progress: state.progress,
+          disabled: state.currentEntryDisabled,
+          scope
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        RelationsList,
+        {
+          progress: state.progress,
+          onChange: onChangeRelationsEntries,
+          groups: state.groups
+        }
+      ),
+      /* @__PURE__ */ jsx(DialogAlert$1, { ref: alertDialogRef })
+    ] });
+  }
+  function renderBody() {
+    if (state.status === DIALOG_STATUS.SUCCESS) {
+      return renderContent();
+    }
+    if (state.status === DIALOG_STATUS.FAILED) {
+      return /* @__PURE__ */ jsx(
+        ContentError,
+        {
+          buttonText: i18n("button_repeat"),
+          errorText: state.error.title || i18n("label_loading-failed"),
+          errorDescription: state.error.description,
+          onClick: refetch
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(ContentLoader, {});
+  }
+  return /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      open: visible,
+      onClose: () => onClose("close", false),
+      disableHeightTransition: true,
+      children: /* @__PURE__ */ jsxs("div", { className: b(), children: [
+        /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n("section_main-title") }),
+        /* @__PURE__ */ jsx(Dialog.Body, { className: b("body"), children: /* @__PURE__ */ jsx("div", { className: b("content"), children: renderBody() }) }),
+        /* @__PURE__ */ jsx(
+          Dialog.Footer,
+          {
+            onClickButtonCancel: () => onClose("close", false),
+            onClickButtonApply: () => apply(),
+            textButtonApply: i18n("button_apply"),
+            textButtonCancel: i18n("button_cancel"),
+            propsButtonApply: { disabled: disableApply },
+            loading: state.progress,
+            children: /* @__PURE__ */ jsx(Button, { view: "outlined", size: "l", disabled: state.progress, onClick: refetch, children: i18n("button_refresh") })
+          }
+        )
+      ] })
+    }
+  );
+}
+const DialogSwitchPublic = (props) => {
+  const onClose = (status, publish) => {
+    if (status === "success") {
+      props.onClose({ status: EntryDialogResolveStatus.Success, data: { publish } });
+    } else {
+      props.onClose({ status: EntryDialogResolveStatus.Close, data: {} });
+    }
+  };
+  return /* @__PURE__ */ jsx(DialogPublic, { ...props, onClose });
+};
+const DialogUnlock = (props) => {
+  const onClose = () => {
+    props.onClose({ status: EntryDialogResolveStatus.Close });
+  };
+  const { DialogAddParticipants } = registry.common.components.getAll();
+  return /* @__PURE__ */ jsx(
+    DialogAddParticipants,
+    {
+      ...props,
+      onClose,
+      onSuccess: onClose,
+      showParticipantsRequests: true,
+      showOwners: true,
+      mode: "request"
+    }
+  );
+};
+var EntryDialogName = /* @__PURE__ */ ((EntryDialogName2) => {
+  EntryDialogName2["Rename"] = "rename";
+  EntryDialogName2["EditFavoritesAlias"] = "edit_favorites_alias";
+  EntryDialogName2["Copy"] = "copy";
+  EntryDialogName2["Move"] = "move";
+  EntryDialogName2["Delete"] = "delete";
+  EntryDialogName2["CreateFolder"] = "create_folder";
+  EntryDialogName2["Access"] = "access";
+  EntryDialogName2["AccessDescription"] = "access_description";
+  EntryDialogName2["Unlock"] = "unlock";
+  EntryDialogName2["CreateDashboard"] = "create_dashboard";
+  EntryDialogName2["CreateWizardChart"] = "create_wizard_chart";
+  EntryDialogName2["SwitchPublic"] = "switch_public";
+  EntryDialogName2["CreateEditorChart"] = "create_editor_chart";
+  EntryDialogName2["CreateQLChart"] = "create_sql_chart";
+  EntryDialogName2["EditWarning"] = "edit-warning";
+  EntryDialogName2["SetActualConfirm"] = "set-actual-confirm";
+  EntryDialogName2["SaveAsNew"] = "save-as-new";
+  EntryDialogName2["MigrateToWorkbook"] = "migrate-to-workbook";
+  EntryDialogName2["ShowRelatedEntities"] = "show-related-entities";
+  EntryDialogName2["Share"] = "share";
+  return EntryDialogName2;
+})(EntryDialogName || {});
+const getMapDialogues = () => {
+  const { getAdditionalEntryDialoguesMap: getAdditionalEntryDialoguesMap2 } = registry.common.functions.getAll();
+  return {
+    [
+      "access"
+      /* Access */
+    ]: DialogAccess,
+    [
+      "access_description"
+      /* AccessDescription */
+    ]: DialogAccessDescription,
+    [
+      "unlock"
+      /* Unlock */
+    ]: DialogUnlock,
+    [
+      "delete"
+      /* Delete */
+    ]: DialogDeleteEntry$1,
+    [
+      "move"
+      /* Move */
+    ]: DialogMoveEntry$1,
+    [
+      "rename"
+      /* Rename */
+    ]: DialogRenameEntry$1,
+    [
+      "edit_favorites_alias"
+      /* EditFavoritesAlias */
+    ]: DialogEditFavoritesAlias,
+    [
+      "copy"
+      /* Copy */
+    ]: DialogCopyEntry$1,
+    [
+      "create_folder"
+      /* CreateFolder */
+    ]: DialogCreateFolder$1,
+    [
+      "create_dashboard"
+      /* CreateDashboard */
+    ]: DialogCreateDashboard$1,
+    [
+      "create_wizard_chart"
+      /* CreateWizardChart */
+    ]: DialogCreateWizardChart$1,
+    [
+      "switch_public"
+      /* SwitchPublic */
+    ]: DialogSwitchPublic,
+    [
+      "create_editor_chart"
+      /* CreateEditorChart */
+    ]: DialogCreateEditorChart$1,
+    [
+      "create_sql_chart"
+      /* CreateQLChart */
+    ]: DialogCreateQLChart$1,
+    [
+      "edit-warning"
+      /* EditWarning */
+    ]: DialogEditWarning$1,
+    [
+      "set-actual-confirm"
+      /* SetActualConfirm */
+    ]: DialogMakeActualConfirm$1,
+    [
+      "save-as-new"
+      /* SaveAsNew */
+    ]: DialogEntrySaveAsNew$1,
+    [
+      "migrate-to-workbook"
+      /* MigrateToWorkbook */
+    ]: DialogMigrateToWorkbook,
+    [
+      "show-related-entities"
+      /* ShowRelatedEntities */
+    ]: DialogRelatedEntities,
+    [
+      "share"
+      /* Share */
+    ]: DialogShareEntry,
+    ...getAdditionalEntryDialoguesMap2()
+  };
+};
+const initState = {
+  dialog: null,
+  resolveOpenDialog: noop,
+  visible: false,
+  dialogProps: {}
+};
+class EntryDialogues extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { ...initState };
+    this.onClose = ({ status, data = {} }) => {
+      const { resolveOpenDialog } = this.state;
+      this.setState({ ...initState });
+      resolveOpenDialog({ status, data });
+    };
+  }
+  render() {
+    let content = null;
+    const mapDialogues = getMapDialogues();
+    if (this.state.dialog !== null && this.state.dialog in mapDialogues) {
+      const dialog = mapDialogues[this.state.dialog];
+      content = React__default.createElement(dialog, {
+        ...this.state.dialogProps,
+        sdk,
+        visible: this.state.visible,
+        onClose: this.onClose
+      });
+    }
+    return content;
+  }
+  // Public method via ref
+  open({
+    dialog,
+    dialogProps
+  }) {
+    return new Promise((resolveOpenDialog) => {
+      this.setState({
+        dialog,
+        resolveOpenDialog,
+        dialogProps,
+        visible: true
+      });
+    });
+  }
+}
+const getAdditionalEntryDialoguesMap = () => {
+  return {};
+};
+export {
+  DialogCreateWorkbookEntry as D,
+  EntryDialogName as E,
+  EntryDialogResolveStatus as a,
+  EntryDialogues as b,
+  EntryDialogBase as c,
+  getAdditionalEntryDialoguesMap as g
+};