@retailcrm/datalens-ui 0.0.0

package/components/Navigation.js

@@ -0,0 +1,2675 @@
+import React__default from "react";
+import noop from "lodash/noop";
+import PropTypes from "prop-types";
+import { D as DL, c7 as PLACE, l as I18n, cB as NavigationMinimalPlaceSelectQa, g as getEntryNameByKey, d as EntryScope, r as registry, Q as DlNavigationQA, ca as normalizeDestination, cC as MAP_PLACE_TO_SCOPE, cD as makeUserId, s as filterUsersIds, bh as Scope } from "./AccessRights.js";
+import { Folders, Star, Thunderbolt, CirclesIntersection, ChartColumn, LayoutCellsLarge, FolderHouse, Ellipsis, FolderArrowDown, TriangleExclamationFill, Lock, Tag, StarFill, Folder } from "@gravity-ui/icons";
+import block from "bem-cn-lite";
+import memoize from "lodash/memoize";
+import { Q as QLChart } from "./EntityIcon.js";
+import { Button, Icon, Breadcrumbs, TextInput, ActionsPanel, Dialog, Popover, Loader, Tooltip, Checkbox, SegmentedRadioGroup, Popup, Select } from "@gravity-ui/uikit";
+import isEqual from "lodash/isEqual";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { u as useRouter, O as navigateHelper_default, U as Utils, q as parseError, f as openDialogErrorWithTabs, V as useEffectOnce, g as getSdk, d as showToast, ab as getResolveUsersByIdsAction, l as logger } from "./ActionPanel.js";
+import { c as copyTextWithToast } from "./DialogRelatedEntities.js";
+import { d as EntryContextMenuBase, b as ENTRY_CONTEXT_MENU_ACTION } from "./EntryContextMenu.js";
+import { E as EntryDialogName, a as EntryDialogResolveStatus, b as EntryDialogues } from "./EntryDialogues.js";
+import debounce from "lodash/debounce";
+import { useDispatch, connect } from "react-redux";
+import { D as DataLensTabs } from "./Tabs.js";
+import { M as MOBILE_SIZE } from "./CollectionFilters.js";
+import { P as PlaceholderIllustration } from "./PlaceholderIllustration.js";
+import { aV as UserSettings } from "./ControlComponents.js";
+import { O as OrderBySelect, S as SORT_TYPE } from "./OrderBySelect.js";
+import { D as DialogCounterProgress } from "./Progress.js";
+import { D as DialogSuccessWithAction } from "./DialogSuccessWithAction.js";
+import { E as EntriesList } from "./EntriesList.js";
+import { P as PathSelect } from "./PathSelect.js";
+import AutoSizer from "react-virtualized-auto-sizer";
+import { VariableSizeList } from "react-window";
+import { E as EntryIcon } from "./EntryIcon.js";
+import moment from "moment";
+import classNames from "classnames";
+const MODE_MINIMAL = "minimal";
+const MODE_FULL = "full";
+const ORDER_DIRECTION = {
+  DESC: "desc",
+  ASC: "asc"
+};
+const ORDER_FIELD = {
+  CREATED_AT: "createdAt",
+  NAME: "name"
+};
+const OWNERSHIP = {
+  ALL: "all",
+  ONLY_MINE: "onlyMine",
+  FAVORITES: "favorites"
+};
+const QUICK_ITEMS = {
+  get USER_FOLDER() {
+    return DL.USER_FOLDER;
+  }
+};
+const PLACE_VALUES = Object.values(PLACE);
+const ROOT_PATH = "/";
+block("dl-navigation-create-entry");
+var CreateMenuValue = /* @__PURE__ */ ((CreateMenuValue2) => {
+  CreateMenuValue2["Folder"] = "folder";
+  CreateMenuValue2["Script"] = "script";
+  CreateMenuValue2["Widget"] = "widget";
+  CreateMenuValue2["QL"] = "ql";
+  CreateMenuValue2["Dashboard"] = "dashboard";
+  CreateMenuValue2["Connection"] = "connection";
+  CreateMenuValue2["Dataset"] = "dataset";
+  return CreateMenuValue2;
+})(CreateMenuValue || {});
+const i18n$f = I18n.keyset("component.navigation.view");
+const b$g = block("dl-navigation-base");
+const getPlacesConfig = memoize(() => {
+  return [
+    {
+      place: PLACE.ROOT,
+      icon: Folders,
+      iconClassName: b$g("sidebar-icon-root"),
+      text: i18n$f("switch_root"),
+      buttonText: i18n$f("button_create"),
+      value: CreateMenuValue.Folder,
+      displayParentFolder: false,
+      filters: {
+        ownership: false,
+        order: true
+      }
+    },
+    {
+      place: PLACE.FAVORITES,
+      icon: Star,
+      iconClassName: b$g("sidebar-icon-favorites"),
+      text: i18n$f("switch_favorites"),
+      buttonText: i18n$f("button_create"),
+      value: CreateMenuValue.Folder,
+      displayParentFolder: true,
+      filters: {
+        ownership: false,
+        order: true
+      }
+    },
+    {
+      place: PLACE.CONNECTIONS,
+      icon: Thunderbolt,
+      iconClassName: b$g("sidebar-icon-connections"),
+      text: i18n$f("switch_connections"),
+      buttonText: i18n$f("button_create-connection"),
+      value: CreateMenuValue.Connection,
+      displayParentFolder: true,
+      filters: {
+        ownership: true,
+        order: true
+      },
+      qa: NavigationMinimalPlaceSelectQa.Connections
+    },
+    {
+      place: PLACE.DATASETS,
+      icon: CirclesIntersection,
+      iconClassName: b$g("sidebar-icon-datasets"),
+      text: i18n$f("switch_datasets"),
+      buttonText: i18n$f("button_create-dataset"),
+      value: CreateMenuValue.Dataset,
+      displayParentFolder: true,
+      filters: {
+        ownership: true,
+        order: true
+      },
+      qa: NavigationMinimalPlaceSelectQa.Datasets
+    },
+    {
+      place: PLACE.WIDGETS,
+      icon: ChartColumn,
+      iconClassName: b$g("sidebar-icon-widgets"),
+      text: i18n$f("switch_widgets"),
+      buttonText: i18n$f("button_create-widget"),
+      value: CreateMenuValue.Widget,
+      displayParentFolder: true,
+      filters: {
+        ownership: true,
+        order: true
+      }
+    },
+    {
+      place: PLACE.DASHBOARDS,
+      icon: LayoutCellsLarge,
+      iconClassName: b$g("sidebar-icon-dashboards"),
+      text: i18n$f("switch_dashboards"),
+      buttonText: i18n$f("button_create-dashboard"),
+      value: CreateMenuValue.Dashboard,
+      displayParentFolder: true,
+      filters: {
+        ownership: true,
+        order: true
+      }
+    }
+  ];
+});
+const getPlaceConfig = memoize(({ place, placesConfig }) => {
+  return place ? placesConfig.find((placeConfig) => placeConfig.place === place) : placesConfig;
+});
+memoize((place) => {
+  const placesConfig = getPlacesConfig();
+  return getPlaceConfig({ place, placesConfig });
+});
+const getQuickItems = memoize(() => {
+  return [
+    {
+      icon: FolderHouse,
+      iconClassName: b$g("sidebar-icon-personal-folder"),
+      text: i18n$f("switch_personal-folder"),
+      scope: "folder",
+      key: QUICK_ITEMS.USER_FOLDER
+    }
+  ];
+});
+const getCreatableEntriesConfig = memoize(() => {
+  return [
+    {
+      value: CreateMenuValue.Widget,
+      icon: ChartColumn,
+      type: "chart-wizard",
+      text: i18n$f("value_create-wizard"),
+      place: PLACE.WIDGETS,
+      submenu: "charts"
+    },
+    {
+      value: CreateMenuValue.QL,
+      icon: QLChart,
+      type: "chart-ql",
+      text: i18n$f("value_create-ql"),
+      place: PLACE.WIDGETS,
+      submenu: "charts"
+    },
+    {
+      value: CreateMenuValue.Dashboard,
+      icon: LayoutCellsLarge,
+      type: "dashboard",
+      text: i18n$f("value_create-dashboard"),
+      place: PLACE.DASHBOARDS,
+      submenu: "other"
+    },
+    {
+      value: CreateMenuValue.Connection,
+      icon: Thunderbolt,
+      type: "connection",
+      text: i18n$f("value_create-connection"),
+      place: PLACE.CONNECTIONS,
+      submenu: "other"
+    },
+    {
+      value: CreateMenuValue.Dataset,
+      icon: CirclesIntersection,
+      type: "dataset",
+      text: i18n$f("value_create-dataset"),
+      place: PLACE.DATASETS,
+      submenu: "other"
+    }
+  ];
+});
+const i18n$e = I18n.keyset("component.navigation.view");
+const isRootPlace = (place) => {
+  return place === PLACE.ROOT;
+};
+const isEntryActiveByType = (includeType, type) => {
+  const emptyArray = [];
+  return emptyArray.concat(includeType).includes(type);
+};
+const checkEntryActivity = (clickableScope, includeType, excludeType) => {
+  return includeType || excludeType ? ({ scope, type }) => {
+    return scope === "folder" || (clickableScope ? clickableScope === scope : true) && (Boolean(includeType) && isEntryActiveByType(includeType, type) || Boolean(excludeType) && !isEntryActiveByType(excludeType, type));
+  } : void 0;
+};
+const getPathDisplayName = ({ path }) => {
+  const name = getEntryNameByKey({ key: path });
+  return name === "" ? i18n$e("switch_root") : name;
+};
+const getPlaceSelectParameters = (items) => {
+  return {
+    items,
+    quickItems: [QUICK_ITEMS.USER_FOLDER]
+  };
+};
+const contextMenuI18n = I18n.keyset("component.entry-context-menu.view");
+const b$f = block("dl-core-navigation-breadcrumb-menu");
+const placement = ["bottom", "bottom-start", "bottom-end"];
+const BreadcrumbMenu = ({
+  breadCrumbs,
+  getContextMenuItems,
+  entryDialoguesRef,
+  currentPageEntry,
+  refresh,
+  onChangeLocation
+}) => {
+  const router = useRouter();
+  const btnRef = React__default.useRef(null);
+  const [show, setShow] = React__default.useState(false);
+  const breadCrumbEntry = React__default.useMemo(() => {
+    const breadCrumb = breadCrumbs[breadCrumbs.length - 1];
+    return {
+      scope: EntryScope.Folder,
+      entryId: breadCrumb.entryId,
+      permissions: breadCrumb.permissions,
+      type: "",
+      key: breadCrumb.path,
+      name: breadCrumb.title,
+      isLocked: breadCrumb.isLocked,
+      workbookId: null
+    };
+  }, [breadCrumbs]);
+  const handleMenuClick = async ({ entry, action }) => {
+    if (!entryDialoguesRef.current) {
+      return;
+    }
+    const isCurrentPageEntryInside = currentPageEntry?.key.toLowerCase().startsWith(entry.key.toLowerCase());
+    const setEntryKey = registry.common.functions.get("setEntryKey");
+    switch (action) {
+      case ENTRY_CONTEXT_MENU_ACTION.RENAME: {
+        const response = await entryDialoguesRef.current.open({
+          dialog: EntryDialogName.Rename,
+          dialogProps: {
+            entryId: entry.entryId,
+            initName: entry.name
+          }
+        });
+        if (response.status === EntryDialogResolveStatus.Success) {
+          const renamedEntry = response.data?.find(
+            (item) => item.entryId === entry.entryId
+          );
+          if (renamedEntry) {
+            onChangeLocation?.(PLACE.ROOT, renamedEntry.key);
+          }
+          if (isCurrentPageEntryInside) {
+            const entryData = response.data ? response.data[0] : null;
+            if (!entryData) {
+              router.reload();
+            }
+            setEntryKey(entryData);
+          }
+        }
+        break;
+      }
+      case ENTRY_CONTEXT_MENU_ACTION.MOVE: {
+        const response = await entryDialoguesRef.current.open({
+          dialog: EntryDialogName.Move,
+          dialogProps: {
+            entryId: entry.entryId,
+            initDestination: Utils.getPathBefore({ path: entry.key }),
+            inactiveEntryKeys: [entry.key]
+          }
+        });
+        if (response.status === EntryDialogResolveStatus.Success) {
+          const destination = response.data?.destination;
+          onChangeLocation?.(PLACE.ROOT, destination ? destination : DL.USER_FOLDER);
+          if (isCurrentPageEntryInside) {
+            const entryData = response.data ? response.data.result[0] : null;
+            if (!entryData) {
+              router.reload();
+            }
+            setEntryKey({ ...entryData, withRouting: false });
+          }
+        }
+        break;
+      }
+      case ENTRY_CONTEXT_MENU_ACTION.COPY: {
+        const response = await entryDialoguesRef.current.open({
+          dialog: EntryDialogName.Copy,
+          dialogProps: {
+            entryId: entry.entryId,
+            scope: entry.scope,
+            initDestination: Utils.getPathBefore({ path: entry.key }),
+            initName: entry.name
+          }
+        });
+        if (response.status === EntryDialogResolveStatus.Success) {
+          refresh?.();
+        }
+        break;
+      }
+      case ENTRY_CONTEXT_MENU_ACTION.COPY_LINK: {
+        copyTextWithToast({
+          copyText: navigateHelper_default.redirectUrlSwitcher(entry),
+          successText: contextMenuI18n("toast_copy-link-success"),
+          errorText: contextMenuI18n("toast_copy-error"),
+          toastName: "toast-menu-copy-link"
+        });
+        break;
+      }
+      case ENTRY_CONTEXT_MENU_ACTION.DELETE: {
+        const response = await entryDialoguesRef.current.open({
+          dialog: EntryDialogName.Delete,
+          dialogProps: {
+            entry
+          }
+        });
+        if (response.status === EntryDialogResolveStatus.Success) {
+          const breadCrumbBefore = breadCrumbs[breadCrumbs.length - 2];
+          onChangeLocation?.(
+            PLACE.ROOT,
+            breadCrumbBefore?.isLocked === false ? breadCrumbBefore.path : DL.USER_FOLDER
+          );
+          if (isCurrentPageEntryInside) {
+            navigateHelper_default.openNavigation();
+          }
+        }
+        break;
+      }
+      case ENTRY_CONTEXT_MENU_ACTION.ACCESS: {
+        await entryDialoguesRef.current.open({
+          dialog: EntryDialogName.Access,
+          dialogProps: {
+            entry
+          }
+        });
+        break;
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        className: b$f(),
+        view: "flat",
+        ref: btnRef,
+        onClick: () => setShow((prevShow) => !prevShow),
+        children: /* @__PURE__ */ jsx(Icon, { data: Ellipsis, size: 16, className: b$f("icon") })
+      }
+    ),
+    show && /* @__PURE__ */ jsx(
+      EntryContextMenuBase,
+      {
+        visible: show,
+        entry: breadCrumbEntry,
+        anchorElement: btnRef.current ?? void 0,
+        items: getContextMenuItems({ entry: breadCrumbEntry }),
+        onMenuClick: handleMenuClick,
+        onClose: () => setShow(false),
+        hasTail: true,
+        popupPlacement: placement
+      }
+    )
+  ] });
+};
+const b$e = block("dl-core-navigation-breadcrumbs");
+const NavigationBreadcrumbs = ({
+  breadCrumbs,
+  place,
+  getPlaceParameters,
+  onClick,
+  enableMenu,
+  className,
+  getContextMenuItems,
+  currentPageEntry,
+  refresh,
+  onChangeLocation
+}) => {
+  const entryDialoguesRef = React__default.useRef(null);
+  const items = React__default.useMemo(() => {
+    const isRoot = isRootPlace(place);
+    const { text } = getPlaceParameters(place);
+    const firstClickedItem = {
+      path: "",
+      name: text
+    };
+    const isFirstLast = !isRoot || breadCrumbs.length === 0;
+    const breadCrumbsItems = [
+      {
+        action: (event) => {
+          onClick(firstClickedItem, event, isFirstLast);
+        },
+        text,
+        qa: "breadcrumbs-item-root",
+        item: firstClickedItem
+      }
+    ];
+    if (isRoot) {
+      breadCrumbsItems.push(
+        ...breadCrumbs.map((item, index) => {
+          const last = breadCrumbs.length - 1 === index;
+          const clickedItem = {
+            path: item.path,
+            name: item.title,
+            entryId: item.entryId
+          };
+          return {
+            action: (event) => {
+              onClick(clickedItem, event, last);
+            },
+            qa: `breadcrumbs-item-${item.title}`,
+            text: item.title,
+            item: clickedItem
+          };
+        })
+      );
+    }
+    return breadCrumbsItems;
+  }, [place, getPlaceParameters, breadCrumbs, onClick]);
+  const showMenu = React__default.useMemo(() => {
+    if (enableMenu && isRootPlace(place) && breadCrumbs.length > 0) {
+      const breadCrumb = breadCrumbs[breadCrumbs.length - 1];
+      return !breadCrumb.isLocked;
+    } else {
+      return false;
+    }
+  }, [enableMenu, place, breadCrumbs]);
+  return /* @__PURE__ */ jsxs("div", { className: b$e(null, className), children: [
+    /* @__PURE__ */ jsx(EntryDialogues, { ref: entryDialoguesRef }),
+    /* @__PURE__ */ jsx("div", { className: b$e("wrapper"), children: /* @__PURE__ */ jsxs("div", { className: b$e("line"), children: [
+      /* @__PURE__ */ jsx(
+        Breadcrumbs,
+        {
+          className: b$e("component", { showMenu }),
+          qa: DlNavigationQA.NavigationBreadcrumbs,
+          children: items.map((item, index) => {
+            const last = index === items.length - 1;
+            return /* @__PURE__ */ jsx(
+              Breadcrumbs.Item,
+              {
+                "data-qa": item.qa,
+                className: b$e("item", { last }),
+                onClick: (event) => {
+                  onClick(item.item, event, last);
+                },
+                disabled: last,
+                children: item.text
+              },
+              index
+            );
+          })
+        }
+      ),
+      showMenu && Boolean(getContextMenuItems) && /* @__PURE__ */ jsx(
+        BreadcrumbMenu,
+        {
+          breadCrumbs,
+          getContextMenuItems,
+          entryDialoguesRef,
+          currentPageEntry,
+          refresh,
+          onChangeLocation
+        }
+      )
+    ] }) })
+  ] });
+};
+const i18n$d = I18n.keyset("component.navigation.view");
+const getTitleByPlace = (scope) => {
+  switch (scope) {
+    case PLACE.ROOT:
+      return i18n$d("label_empty-folder");
+    case PLACE.FAVORITES:
+      return i18n$d("label_empty-favorites");
+    case PLACE.CONNECTIONS:
+      return i18n$d("label_empty-connections");
+    case PLACE.DATASETS:
+      return i18n$d("label_empty-datasets");
+    case PLACE.WIDGETS:
+      return i18n$d("label_empty-widgets");
+    case PLACE.DASHBOARDS:
+      return i18n$d("label_empty-dashboards");
+    case PLACE.REPORTS:
+      return i18n$d("label_empty-reports");
+    default:
+      return i18n$d("label_empty");
+  }
+};
+const getDescriptionByPlace = (scope) => {
+  switch (scope) {
+    case PLACE.CONNECTIONS:
+      return i18n$d("label-description_empty-connections");
+    case PLACE.DATASETS:
+      return i18n$d("label-description_empty-datasets");
+    case PLACE.WIDGETS:
+      return i18n$d("label-description_empty-widgets");
+    case PLACE.DASHBOARDS:
+      return i18n$d("label-description_empty-dashboards");
+    case PLACE.REPORTS:
+      return i18n$d("label-description_empty-reports");
+    default:
+      return "";
+  }
+};
+const i18n$c = I18n.keyset("component.navigation.view");
+const b$d = block("dl-navigation-empty-state");
+const HIDE_ACTION_PLACES = [PLACE.FAVORITES];
+const EmptyState = ({
+  isEmptyFolder,
+  className,
+  mode,
+  place,
+  renderAction
+}) => {
+  const emptyText = isEmptyFolder ? getTitleByPlace(place) : i18n$c("label_not-found");
+  const emptyDescription = isEmptyFolder ? getDescriptionByPlace(place) : "";
+  const isTemplatePlace = place !== PLACE.ROOT;
+  const emptyFolderName = isTemplatePlace ? "template" : "emptyDirectory";
+  const name = isEmptyFolder ? emptyFolderName : "notFound";
+  const illustrationSize = mode === MODE_MINIMAL && !DL.IS_MOBILE ? "m" : "l";
+  const renderTemplateAction = isEmptyFolder && isTemplatePlace && !HIDE_ACTION_PLACES.includes(place) ? () => /* @__PURE__ */ jsx("div", { className: b$d("action"), children: renderAction() }) : void 0;
+  return /* @__PURE__ */ jsx("div", { className, children: /* @__PURE__ */ jsx(
+    PlaceholderIllustration,
+    {
+      name,
+      title: emptyText,
+      description: emptyDescription,
+      direction: "column",
+      size: illustrationSize,
+      renderAction: renderTemplateAction
+    }
+  ) });
+};
+class NavigationSettings {
+  constructor() {
+    this.instance = UserSettings.getInstance();
+  }
+  setOrderBy(field, direction) {
+    this.instance.updateUserSettings({
+      dlNavFilterOrderByField: field,
+      dlNavFilterOrderByDirection: direction
+    });
+  }
+  getOrderBy() {
+    const { dlNavFilterOrderByField, dlNavFilterOrderByDirection } = this.instance.getSettings();
+    let field = dlNavFilterOrderByField;
+    let direction = dlNavFilterOrderByDirection;
+    if (!(field && direction)) {
+      field = ORDER_FIELD.CREATED_AT;
+      direction = ORDER_DIRECTION.DESC;
+    }
+    return { field, direction };
+  }
+  setCreatedBy(createdBy) {
+    this.instance.updateUserSettings({
+      dlNavFilterCreatedBy: createdBy
+    });
+  }
+  getCreatedBy() {
+    return this.instance.getSettings().dlNavFilterCreatedBy || "";
+  }
+}
+const b$c = block("dl-core-navigation-error");
+const i18n$b = I18n.keyset("component.navigation.view");
+function ErrorView({ error, onRetryClick }) {
+  const { status } = parseError(error);
+  let errorViewConfig;
+  switch (status) {
+    case 403: {
+      errorViewConfig = {
+        title: i18n$b("label_access-denied-folder"),
+        name: "noAccess"
+      };
+      break;
+    }
+    default: {
+      errorViewConfig = {
+        title: i18n$b("label_failed-load-navigation"),
+        name: "error",
+        renderAction: () => /* @__PURE__ */ jsx(
+          Button,
+          {
+            view: "action",
+            size: "l",
+            className: b$c("button-retry"),
+            onClick: onRetryClick,
+            children: i18n$b("button_retry")
+          }
+        )
+      };
+    }
+  }
+  return /* @__PURE__ */ jsx("div", { className: b$c(), children: /* @__PURE__ */ jsx(PlaceholderIllustration, { ...errorViewConfig, size: "promo", direction: "column" }) });
+}
+const i18n$a = I18n.keyset("component.navigation.view");
+function getItemsOrderBy() {
+  return {
+    [SORT_TYPE.ALPHABET_ASC]: {
+      field: ORDER_FIELD.NAME,
+      direction: ORDER_DIRECTION.ASC,
+      content: i18n$a("value_name-ascending")
+    },
+    [SORT_TYPE.ALPHABET_DESC]: {
+      field: ORDER_FIELD.NAME,
+      direction: ORDER_DIRECTION.DESC,
+      content: i18n$a("value_name-descending")
+    },
+    [SORT_TYPE.FIRST_NEW]: {
+      field: ORDER_FIELD.CREATED_AT,
+      direction: ORDER_DIRECTION.DESC,
+      content: i18n$a("value_date-descending")
+    },
+    [SORT_TYPE.FIRST_OLD]: {
+      field: ORDER_FIELD.CREATED_AT,
+      direction: ORDER_DIRECTION.ASC,
+      content: i18n$a("value_date-ascending")
+    }
+  };
+}
+const OrderSelect = ({ orderBy, onChange, disabled }) => {
+  const orderByOptions = React__default.useMemo(() => getItemsOrderBy(), []);
+  return /* @__PURE__ */ jsx(OrderBySelect, { ...{ orderBy, orderByOptions, onChange, disabled } });
+};
+const b$b = block("dl-core-navigation-search");
+class SearchInput extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.refInput = React__default.createRef();
+  }
+  render() {
+    const { text, placeholder, onChange, disabled } = this.props;
+    return /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        className: b$b(),
+        qa: DlNavigationQA.SearchInput,
+        controlRef: this.refInput,
+        hasClear: true,
+        placeholder,
+        value: text,
+        onUpdate: onChange,
+        disabled
+      }
+    );
+  }
+  focus() {
+    this.refInput.current?.focus();
+  }
+}
+const i18n$9 = I18n.keyset("component.navigation.view");
+const BatchPanel = ({ count, className, onAction, onClose }) => {
+  const actions = React__default.useMemo(
+    () => [
+      {
+        id: "move",
+        button: {
+          props: {
+            children: [
+              /* @__PURE__ */ jsx(Icon, { data: FolderArrowDown, size: "16" }, "icon"),
+              i18n$9("button_move")
+            ],
+            onClick: () => onAction("move")
+          }
+        },
+        dropdown: {
+          item: {
+            action: () => onAction("move"),
+            text: i18n$9("button_move")
+          }
+        }
+      }
+    ],
+    [onAction]
+  );
+  return /* @__PURE__ */ jsx(
+    ActionsPanel,
+    {
+      actions,
+      className,
+      onClose,
+      renderNote: () => i18n$9("label_batch-selected-entries-count", { value: count })
+    }
+  );
+};
+const b$a = block("dl-nav-move-access-error");
+const i18n$8 = I18n.keyset("component.navigation.view");
+const AccessError = ({ onClose, onNext, entries, entriesWithRights }) => {
+  const entryDialoguesRef = React__default.useRef(null);
+  const entriesWithoutMoveRights = React__default.useMemo(() => {
+    const entriesIdsWithRights = new Set(entriesWithRights.map(({ entryId }) => entryId));
+    return entries.filter(({ entryId }) => !entriesIdsWithRights.has(entryId));
+  }, [entries, entriesWithRights]);
+  const hasButtonApply = entries.length !== entriesWithoutMoveRights.length;
+  const handleClickRequestRights = (item) => {
+    entryDialoguesRef.current?.open({
+      dialog: EntryDialogName.Unlock,
+      dialogProps: {
+        entry: item
+      }
+    });
+  };
+  return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    /* @__PURE__ */ jsxs(Dialog, { open: true, onClose, className: b$a(), children: [
+      /* @__PURE__ */ jsx(
+        Dialog.Header,
+        {
+          caption: i18n$8("section_batch-move-access-error"),
+          insertBefore: /* @__PURE__ */ jsx(
+            Icon,
+            {
+              data: TriangleExclamationFill,
+              className: b$a("header-icon"),
+              size: "24"
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsxs("div", { className: b$a("content"), children: [
+        /* @__PURE__ */ jsx("div", { className: b$a("description"), children: i18n$8("label_batch-move-access-error-description") }),
+        /* @__PURE__ */ jsx(
+          EntriesList,
+          {
+            className: b$a("list"),
+            entries: entriesWithoutMoveRights,
+            renderAction: (item) => /* @__PURE__ */ jsx(
+              Button,
+              {
+                view: "outlined",
+                onClick: () => handleClickRequestRights(item),
+                children: i18n$8("button_request-rights")
+              }
+            )
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsx(
+        Dialog.Footer,
+        {
+          onClickButtonCancel: onClose,
+          textButtonCancel: hasButtonApply ? i18n$8("button_cancel") : i18n$8("button_close"),
+          onClickButtonApply: hasButtonApply ? onNext : void 0,
+          textButtonApply: hasButtonApply ? i18n$8("button_continue-anyway") : void 0
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(EntryDialogues, { ref: entryDialoguesRef })
+  ] });
+};
+const b$9 = block("dl-nav-move-error");
+const i18n$7 = I18n.keyset("component.navigation.view");
+const MoveError = ({ onClose, entries, errors }) => {
+  const dispatch = useDispatch();
+  const failedEntries = React__default.useMemo(() => {
+    return errors.map(({ itemIndex }) => entries[itemIndex]);
+  }, [entries, errors]);
+  const handleClickDetails = (itemIndex) => {
+    dispatch(
+      openDialogErrorWithTabs({
+        title: i18n$7("section_batch-move-error"),
+        error: errors[itemIndex].error,
+        withReport: true
+      })
+    );
+  };
+  return /* @__PURE__ */ jsx(React__default.Fragment, { children: /* @__PURE__ */ jsxs(Dialog, { open: true, onClose, className: b$9(), children: [
+    /* @__PURE__ */ jsx(
+      Dialog.Header,
+      {
+        caption: i18n$7("section_batch-move-error"),
+        insertBefore: /* @__PURE__ */ jsx(
+          Icon,
+          {
+            data: TriangleExclamationFill,
+            className: b$9("header-icon"),
+            height: "24",
+            width: "24"
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsx("div", { className: b$9("content"), children: /* @__PURE__ */ jsx(
+      EntriesList,
+      {
+        className: b$9("list"),
+        entries: failedEntries,
+        renderAction: (_item, itemIndex) => /* @__PURE__ */ jsx(
+          Button,
+          {
+            view: "outlined",
+            onClick: () => handleClickDetails(itemIndex),
+            children: i18n$7("button_details")
+          }
+        )
+      }
+    ) }) }),
+    /* @__PURE__ */ jsx(
+      Dialog.Footer,
+      {
+        onClickButtonCancel: onClose,
+        textButtonCancel: i18n$7("button_close")
+      }
+    )
+  ] }) });
+};
+const b$8 = block("dl-nav-move-select-destination");
+const i18n$6 = I18n.keyset("component.navigation.view");
+const SelectDestination = ({
+  onClose,
+  entries,
+  onSelectDestionation
+}) => {
+  const [path, setPath] = React__default.useState(() => Utils.getPathBefore({ path: entries[0].key }));
+  const inactiveEntryKeys = React__default.useMemo(() => {
+    const folders = entries.filter((entry) => entry.scope === EntryScope.Folder);
+    return folders.length > 0 ? folders.map((entry) => entry.key) : void 0;
+  }, [entries]);
+  const handleChoosePath = (value) => setPath(normalizeDestination(value));
+  const handlerApplyClick = () => {
+    const hasChanges = path !== Utils.getPathBefore({ path: entries[0].key });
+    onSelectDestionation(path, hasChanges);
+  };
+  return /* @__PURE__ */ jsxs(Dialog, { size: "s", open: true, onClose, children: [
+    /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n$6("section_batch-move-select-destination") }),
+    /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsx("div", { className: b$8("content"), children: /* @__PURE__ */ jsx(
+      PathSelect,
+      {
+        size: "l",
+        defaultPath: path,
+        withInput: false,
+        onChoosePath: handleChoosePath,
+        inactiveEntryKeys
+      }
+    ) }) }),
+    /* @__PURE__ */ jsx(
+      Dialog.Footer,
+      {
+        onClickButtonCancel: onClose,
+        textButtonCancel: i18n$6("button_cancel"),
+        onClickButtonApply: handlerApplyClick,
+        textButtonApply: i18n$6("button_apply")
+      }
+    )
+  ] });
+};
+const CONCURRENT_ID = "batchMoveEntry";
+const i18n$5 = I18n.keyset("component.navigation.view");
+const BatchMove = ({
+  entries,
+  onClose,
+  refreshNavigation,
+  onChangeLocation
+}) => {
+  const [dialogName, setDialogName] = React__default.useState(null);
+  const [errors, setErrors] = React__default.useState([]);
+  const [countMoved, setCountMoved] = React__default.useState(0);
+  const [destination, setDestination] = React__default.useState("");
+  const moveCancelled = React__default.useRef(false);
+  const entriesWithRights = React__default.useMemo(() => {
+    return entries.filter((entry) => entry.permissions.admin === true);
+  }, [entries]);
+  useEffectOnce(() => {
+    const hasAccessError = entriesWithRights.length !== entries.length;
+    setDialogName(hasAccessError ? "access" : "destination");
+  });
+  const cancelRequests = () => {
+    moveCancelled.current = true;
+    getSdk().cancelRequest(CONCURRENT_ID);
+  };
+  const handleCloseAndRefresh = () => {
+    cancelRequests();
+    refreshNavigation();
+    onClose();
+  };
+  const handleClose = () => {
+    cancelRequests();
+    onClose();
+  };
+  const handleOpenFolder = () => {
+    onChangeLocation(PLACE.ROOT, destination);
+  };
+  const handleSelectDestination = async (path, hasChanges) => {
+    if (!hasChanges) {
+      handleClose();
+      return;
+    }
+    setDialogName("progress");
+    setDestination(path);
+    let hasErrors = false;
+    for (const [index, entry] of entriesWithRights.entries()) {
+      try {
+        await getSdk().sdk.us.moveEntry(
+          {
+            entryId: entry.entryId,
+            destination: path
+          },
+          { concurrentId: CONCURRENT_ID }
+        );
+      } catch (error) {
+        if (getSdk().sdk.isCancel(error)) {
+          moveCancelled.current = true;
+          break;
+        }
+        hasErrors = true;
+        setErrors((prevErrors) => [
+          ...prevErrors,
+          {
+            error,
+            itemIndex: index
+          }
+        ]);
+      } finally {
+        setCountMoved((prevCount) => prevCount + 1);
+      }
+    }
+    if (moveCancelled.current) {
+      return;
+    }
+    setDialogName(hasErrors ? "error" : "success");
+  };
+  const handleNextAfterAccessError = () => setDialogName("destination");
+  switch (dialogName) {
+    case "progress":
+      return /* @__PURE__ */ jsx(
+        DialogCounterProgress,
+        {
+          count: entriesWithRights.length,
+          value: countMoved,
+          onClose: handleCloseAndRefresh,
+          hasError: errors.length > 0,
+          textButtonCancel: i18n$5("button_cancel"),
+          caption: i18n$5("section_batch-move-progress")
+        }
+      );
+    case "success":
+      return /* @__PURE__ */ jsx(
+        DialogSuccessWithAction,
+        {
+          onClose: handleCloseAndRefresh,
+          onClick: handleOpenFolder,
+          title: i18n$5("label_batch-move-success-description"),
+          buttonText: i18n$5("button_goto-folder")
+        }
+      );
+    case "access":
+      return /* @__PURE__ */ jsx(
+        AccessError,
+        {
+          onClose: handleClose,
+          entries,
+          entriesWithRights,
+          onNext: handleNextAfterAccessError
+        }
+      );
+    case "error":
+      return /* @__PURE__ */ jsx(
+        MoveError,
+        {
+          onClose: handleCloseAndRefresh,
+          entries: entriesWithRights,
+          errors
+        }
+      );
+    case "destination":
+      return /* @__PURE__ */ jsx(
+        SelectDestination,
+        {
+          onClose: handleClose,
+          entries: entriesWithRights,
+          onSelectDestionation: handleSelectDestination
+        }
+      );
+    default:
+      return null;
+  }
+};
+const BatchDialog = ({
+  action,
+  onClose,
+  entries,
+  selectedIds,
+  refreshNavigation,
+  onChangeLocation
+}) => {
+  const selectedEntries = entries.filter((entry) => selectedIds.has(entry.entryId));
+  switch (action) {
+    case "move":
+      return /* @__PURE__ */ jsx(
+        BatchMove,
+        {
+          onClose,
+          entries: selectedEntries,
+          refreshNavigation,
+          onChangeLocation
+        }
+      );
+    default:
+      return null;
+  }
+};
+const EntryContextButton = ({ onClick, entry, className }) => {
+  const buttonRef = React__default.useRef(null);
+  const handleClick = (event) => {
+    event.stopPropagation();
+    event.preventDefault();
+    onClick({ event, buttonRef, entry });
+  };
+  return /* @__PURE__ */ jsx("div", { className, onClick: handleClick, ref: buttonRef, children: /* @__PURE__ */ jsx(Icon, { data: Ellipsis, size: 16 }) });
+};
+const b$7 = block("dl-core-navigation-favorites-alias");
+const i18n$4 = I18n.keyset("component.navigation.view");
+const TagIcon = ({ isAliasVisible, name }) => {
+  return /* @__PURE__ */ jsx(React__default.Fragment, { children: isAliasVisible ? /* @__PURE__ */ jsx(
+    Popover,
+    {
+      placement: ["right", "left", "bottom", "top"],
+      content: /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+        i18n$4("label_original-name"),
+        ": ",
+        /* @__PURE__ */ jsx("b", { children: name })
+      ] }),
+      children: /* @__PURE__ */ jsx(Icon, { data: Tag })
+    }
+  ) : /* @__PURE__ */ jsx(Icon, { data: Tag }) });
+};
+const FavoritesNameWithAliasItem = (props) => {
+  const { name, displayAlias, isLocked, className, onMenuClick } = props;
+  const onLabelClick = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    onMenuClick?.({
+      entry: { entryId: props.entryId, displayAlias: props.displayAlias },
+      action: ENTRY_CONTEXT_MENU_ACTION.EDIT_FAVORITES_ALIAS
+    });
+  };
+  const isAliasVisible = Boolean(displayAlias);
+  const showTag = isAliasVisible || !DL.IS_MOBILE;
+  const text = displayAlias ? displayAlias : name;
+  return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    /* @__PURE__ */ jsxs("div", { title: text, className: b$7("name-line"), children: [
+      /* @__PURE__ */ jsx("span", { children: text }),
+      isLocked ? /* @__PURE__ */ jsx(Icon, { data: Lock, className: b$7("lock") }) : null
+    ] }),
+    showTag && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: classNames(className, b$7("edit-favorites-alias-btn")),
+        onClick: onLabelClick,
+        children: /* @__PURE__ */ jsx(TagIcon, { name, isAliasVisible })
+      }
+    )
+  ] });
+};
+const collectionIcon = "data:image/svg+xml,%3csvg%20width='16'%20height='16'%20viewBox='0%200%2016%2016'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3crect%20x='2.6'%20y='2.6'%20width='4.21935'%20height='4.21935'%20rx='0.948387'%20stroke='currentColor'%20stroke-opacity='0.85'%20stroke-width='1.2'/%3e%3crect%20x='9.18063'%20y='2.6'%20width='4.21935'%20height='4.21935'%20rx='0.948387'%20stroke='currentColor'%20stroke-opacity='0.85'%20stroke-width='1.2'/%3e%3crect%20x='2.6'%20y='9.18053'%20width='4.21935'%20height='4.21935'%20rx='0.948387'%20stroke='currentColor'%20stroke-opacity='0.85'%20stroke-width='1.2'/%3e%3crect%20x='9.18063'%20y='9.18053'%20width='4.21935'%20height='4.21935'%20rx='0.948387'%20stroke='currentColor'%20stroke-opacity='0.85'%20stroke-width='1.2'/%3e%3c/svg%3e";
+const workbookIcon = "data:image/svg+xml,%3csvg%20width='16'%20height='16'%20viewBox='0%200%2016%2016'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3crect%20x='1.93331'%20y='1.93334'%20width='12.1333'%20height='12.1333'%20rx='0.733333'%20stroke='currentColor'%20stroke-opacity='0.85'%20stroke-width='1.2'/%3e%3cpath%20d='M7.71725%205.42893C7.84256%205.21258%208.15749%205.21258%208.28279%205.42893L10.6887%209.58277C10.8118%209.79527%2010.6599%2010.0667%2010.4059%2010.0667H5.59411C5.34016%2010.0667%205.18825%209.79527%205.31133%209.58277L7.71725%205.42893Z'%20stroke='currentColor'%20stroke-opacity='0.85'%20stroke-width='1.2'/%3e%3c/svg%3e";
+const b$6 = block("dl-core-navigation-table-view");
+const i18n$3 = I18n.keyset("component.navigation.view");
+const CollectionOrWorkbookItem = ({ id, title, isWorkbook }) => {
+  const router = useRouter();
+  const link = isWorkbook ? `/workbooks/${id}` : `/collections/${id}`;
+  const icon = isWorkbook ? workbookIcon : collectionIcon;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: b$6("parent-folder"),
+      onClick: (event) => {
+        event.stopPropagation();
+        event.preventDefault();
+        router.push(link);
+        router.reload();
+      },
+      children: [
+        /* @__PURE__ */ jsx(Icon, { className: b$6("folder-inline"), data: icon, size: 13 }),
+        /* @__PURE__ */ jsx("span", { className: b$6("parent-folder-name"), children: title })
+      ]
+    }
+  );
+};
+class Row extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.onChangeCheckBox = (event) => {
+      this.props.onEntrySelect(this.props.entry.entryId, this.props.index, {
+        shiftKey: Boolean("shiftKey" in event.nativeEvent && event.nativeEvent.shiftKey)
+      });
+    };
+    this.onClickCheckBox = (event) => {
+      if (!this.isLockedEntry()) {
+        if (event.target === event.currentTarget) {
+          event.preventDefault();
+        }
+        event.stopPropagation();
+      }
+    };
+    this.onChangeFavorite = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      this.props.onChangeFavorite(this.props.entry);
+    };
+    this.onEntryParentClick = (event) => {
+      event.stopPropagation();
+      event.preventDefault();
+      this.props.onEntryParentClick?.(this.getParentFolderEntry(), event);
+    };
+    this.onClick = (event) => {
+      this.props.onEntryClick?.(this.props.entry, event);
+    };
+  }
+  render() {
+    const {
+      entry,
+      currentEntryContext,
+      currentPageEntry,
+      displayParentFolder,
+      linkWrapper,
+      mode,
+      place,
+      isBatchEnabled,
+      isOnlyCollectionsMode,
+      onMenuClick
+    } = this.props;
+    const { name, entryId, hidden = false } = entry;
+    const isLocked = this.isLockedEntry();
+    const inactive = !this.isEntryActive();
+    const hovered = currentEntryContext?.entryId === entry.entryId;
+    const highlight = currentPageEntry?.entryId === entry.entryId;
+    const checked = this.isCheckedEntry();
+    const iconSize = DL.IS_MOBILE ? MOBILE_SIZE.NAVIGATION_ICON : 24;
+    const entityIconSize = DL.IS_MOBILE ? MOBILE_SIZE.ENTITY_ICON : "s";
+    const isFavoritesNameAliasesEnabled = place === PLACE.FAVORITES;
+    const visible = "displayAlias" in entry && Boolean(entry.displayAlias);
+    const nameElement = isFavoritesNameAliasesEnabled ? /* @__PURE__ */ jsx(
+      FavoritesNameWithAliasItem,
+      {
+        entryId,
+        name,
+        displayAlias: "displayAlias" in entry ? entry.displayAlias : void 0,
+        isLocked,
+        onMenuClick,
+        className: b$6("edit-favorites-alias-btn", { visible })
+      }
+    ) : /* @__PURE__ */ jsxs("div", { title: name, className: b$6("name-line"), children: [
+      /* @__PURE__ */ jsx("span", { children: name }),
+      isLocked ? /* @__PURE__ */ jsx(Icon, { data: Lock, className: b$6("lock") }) : null
+    ] });
+    const node = /* @__PURE__ */ jsxs("div", { className: b$6("row-link-wrap"), onClick: this.onClick, children: [
+      /* @__PURE__ */ jsx(
+        EntryIcon,
+        {
+          entry,
+          className: b$6("icon"),
+          size: iconSize,
+          entityIconSize
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: b$6("info"), children: [
+        /* @__PURE__ */ jsxs("div", { className: b$6("name"), children: [
+          nameElement,
+          displayParentFolder && this.renderParentFolder()
+        ] }),
+        this.renderDetails()
+      ] })
+    ] });
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: b$6("row", {
+          hovered,
+          mode,
+          highlight,
+          hidden,
+          inactive,
+          checked,
+          withParentFolder: displayParentFolder,
+          withCheckbox: isBatchEnabled && !isOnlyCollectionsMode
+        }),
+        "data-qa": DlNavigationQA.Row,
+        children: [
+          !isOnlyCollectionsMode && isBatchEnabled && this.renderCheckBox(),
+          linkWrapper ? linkWrapper({ entry, className: b$6("link"), children: node }) : /* @__PURE__ */ jsx("div", { className: b$6("link"), children: node })
+        ]
+      }
+    );
+  }
+  renderCheckBox() {
+    return /* @__PURE__ */ jsx("div", { className: b$6("selection-checkbox"), onClick: this.onClickCheckBox, children: this.isWorkbookEntry() ? /* @__PURE__ */ jsx(Tooltip, { content: i18n$3("tooltip_table-move-denied"), children: /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(Checkbox, { size: "l", disabled: true }) }) }) : /* @__PURE__ */ jsx(
+      Checkbox,
+      {
+        size: "l",
+        checked: this.isCheckedEntry(),
+        disabled: this.isLockedEntry(),
+        onChange: this.onChangeCheckBox
+      }
+    ) });
+  }
+  renderDetails() {
+    const { entry, onEntryContextClick, currentEntryContext, mode } = this.props;
+    const { createdBy, createdAt, isFavorite } = entry;
+    const isLocked = this.isLockedEntry();
+    const inactive = !this.isEntryActive();
+    const visibleBtn = !inactive && !isLocked;
+    const hovered = currentEntryContext?.entryId === entry.entryId;
+    const { getLoginById } = registry.common.functions.getAll();
+    const LoginById = getLoginById();
+    switch (mode) {
+      case "minimal": {
+        const date = moment(createdAt).format("DD.MM.YY");
+        return /* @__PURE__ */ jsx("div", { title: date, className: b$6("date"), children: /* @__PURE__ */ jsx("span", { children: date }) });
+      }
+      case "modal":
+      case "full": {
+        const dateFormat = mode === "full" ? "DD MMMM YYYY" : "DD.MM.YY";
+        const date = moment(createdAt).format(dateFormat);
+        return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+          LoginById && /* @__PURE__ */ jsx("div", { className: b$6("createdBy"), children: /* @__PURE__ */ jsx(LoginById, { loginOrId: createdBy, view: "secondary" }) }),
+          /* @__PURE__ */ jsx("div", { title: date, className: b$6("date"), children: /* @__PURE__ */ jsx("span", { children: date }) }),
+          /* @__PURE__ */ jsxs("div", { className: b$6("row-btns"), children: [
+            (!isLocked || isFavorite) && /* @__PURE__ */ jsxs(
+              "div",
+              {
+                className: b$6("row-btn", b$6("btn-change-favorite", { isFavorite })),
+                onClick: this.onChangeFavorite,
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { className: b$6("icon-star-fill"), data: StarFill }),
+                  /* @__PURE__ */ jsx(Icon, { className: b$6("icon-star-stroke"), data: Star })
+                ]
+              }
+            ),
+            visibleBtn && /* @__PURE__ */ jsx(
+              EntryContextButton,
+              {
+                className: b$6("row-btn", { hovered }),
+                entry,
+                onClick: onEntryContextClick
+              }
+            )
+          ] })
+        ] });
+      }
+      default:
+        return null;
+    }
+  }
+  getParentFolderEntry() {
+    const { entry } = this.props;
+    const path = Utils.getPathBefore({ path: entry.key });
+    return {
+      scope: "folder",
+      key: path,
+      name: getPathDisplayName({ path }),
+      parent: true
+    };
+  }
+  renderParentFolder() {
+    if (this.props.entry.workbookId) {
+      return /* @__PURE__ */ jsx(
+        CollectionOrWorkbookItem,
+        {
+          id: this.props.entry.workbookId,
+          title: this.props.entry.workbookTitle,
+          isWorkbook: true
+        }
+      );
+    }
+    if (this.props.entry.collectionId) {
+      return /* @__PURE__ */ jsx(
+        CollectionOrWorkbookItem,
+        {
+          id: this.props.entry.collectionId,
+          title: this.props.entry.collectionTitle,
+          isWorkbook: false
+        }
+      );
+    }
+    const parentEntry = this.getParentFolderEntry();
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: b$6("parent-folder"),
+        onClick: this.onEntryParentClick,
+        title: this.props.entry.key,
+        children: [
+          /* @__PURE__ */ jsx(Icon, { className: b$6("folder-inline"), data: Folder, size: 13 }),
+          /* @__PURE__ */ jsx("span", { className: b$6("parent-folder-name"), children: parentEntry.name })
+        ]
+      }
+    );
+  }
+  isEntryActive() {
+    const { entry, clickableScope, inactiveEntryKeys, inactiveEntryIds, checkEntryActivity: checkEntryActivity2 } = this.props;
+    if (Array.isArray(inactiveEntryIds) && inactiveEntryIds.includes(entry.entryId)) {
+      return false;
+    }
+    if (checkEntryActivity2) {
+      return checkEntryActivity2(entry);
+    }
+    if (Array.isArray(inactiveEntryKeys) && inactiveEntryKeys.some(
+      (inactiveKey) => entry.key.toLowerCase().startsWith(inactiveKey.toLowerCase())
+    )) {
+      return false;
+    }
+    if (clickableScope) {
+      return entry.scope === "folder" || clickableScope === entry.scope;
+    }
+    return true;
+  }
+  isLockedEntry() {
+    return Boolean(this.props.entry.isLocked);
+  }
+  isWorkbookEntry() {
+    return Boolean(this.props.entry.workbookId);
+  }
+  isCheckedEntry() {
+    return this.props.selectedIds.has(this.props.entry.entryId);
+  }
+}
+const RowLoaderMore = () => {
+  return /* @__PURE__ */ jsx("div", { className: b$6("row-loader-more"), children: /* @__PURE__ */ jsx(Loader, { size: "m" }) });
+};
+const b$5 = block("dl-core-navigation-table-view");
+const i18n$2 = I18n.keyset("component.navigation.view");
+const RowHeader = ({
+  mode,
+  displayParentFolder,
+  isAllCheckBoxChecked,
+  onAllCheckBoxSelect,
+  isOnlyCollectionsMode
+}) => {
+  const { getLoginById } = registry.common.functions.getAll();
+  const isLoginByIdExist = Boolean(getLoginById());
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: b$5("row", {
+        mode,
+        header: true,
+        withParentFolder: displayParentFolder
+      }),
+      children: [
+        !isOnlyCollectionsMode && /* @__PURE__ */ jsx("div", { className: b$5("selection-checkbox"), children: /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            size: "l",
+            checked: isAllCheckBoxChecked,
+            disabled: false,
+            onUpdate: onAllCheckBoxSelect
+          }
+        ) }),
+        /* @__PURE__ */ jsx("div", { className: b$5("row-link-wrap"), children: /* @__PURE__ */ jsx("div", { className: b$5("link"), children: /* @__PURE__ */ jsxs("div", { className: b$5("info"), children: [
+          /* @__PURE__ */ jsxs("div", { className: b$5("name"), children: [
+            /* @__PURE__ */ jsx("div", { className: b$5("name-line"), children: /* @__PURE__ */ jsx("span", { children: i18n$2("label_table-column-entry-name") }) }),
+            displayParentFolder && /* @__PURE__ */ jsxs("div", { className: b$5("parent-folder"), children: [
+              /* @__PURE__ */ jsx("div", { className: b$5("folder-inline") }),
+              /* @__PURE__ */ jsx("span", { className: b$5("parent-folder-name") })
+            ] })
+          ] }),
+          isLoginByIdExist && /* @__PURE__ */ jsx("div", { className: b$5("createdBy"), children: /* @__PURE__ */ jsx("span", { children: i18n$2("label_table-column-author") }) }),
+          /* @__PURE__ */ jsx("div", { className: b$5("date"), children: /* @__PURE__ */ jsx("span", { children: i18n$2("label_table-column-date") }) }),
+          /* @__PURE__ */ jsx("div", { className: b$5("row-btns") })
+        ] }) }) })
+      ]
+    }
+  );
+};
+const b$4 = block("dl-core-navigation-table-view");
+const ROW_HEIGHT = 40;
+const InnerElementTypeContext = React__default.createContext({
+  mode: "full",
+  isBatchEnabled: false,
+  showBatchPanel: false,
+  displayParentFolder: false,
+  isAllCheckBoxChecked: false,
+  onAllCheckBoxSelect: () => {
+  },
+  isOnlyCollectionsMode: false
+});
+const InnerElementType = React__default.forwardRef(
+  function InnerElementType2({ children, ...rest }, ref) {
+    const {
+      showBatchPanel,
+      mode,
+      isBatchEnabled,
+      isOnlyCollectionsMode,
+      displayParentFolder,
+      isAllCheckBoxChecked,
+      onAllCheckBoxSelect
+    } = React__default.useContext(InnerElementTypeContext);
+    return /* @__PURE__ */ jsxs("div", { ref, className: b$4("list", { showBatchPanel }), ...rest, children: [
+      isBatchEnabled && /* @__PURE__ */ jsx(
+        RowHeader,
+        {
+          mode,
+          displayParentFolder,
+          isAllCheckBoxChecked,
+          onAllCheckBoxSelect,
+          isOnlyCollectionsMode
+        }
+      ),
+      children
+    ] });
+  }
+);
+class List extends React__default.PureComponent {
+  constructor() {
+    super(...arguments);
+    this.listRef = React__default.createRef();
+    this.onScroll = () => {
+      if (this.props.currentEntryContext) {
+        this.props.onCloseEntryContextMenu();
+      }
+    };
+    this.rowRenderer = ({ index, style }) => {
+      const { hasNextPage, entries, isBatchEnabled } = this.props;
+      if (isBatchEnabled && index === 0) {
+        return null;
+      }
+      const entryIndex = index - this.getHeaderItemsCount();
+      const isLastRow = entries.length === entryIndex;
+      const entry = entries[entryIndex];
+      return /* @__PURE__ */ jsx("div", { style, className: b$4("row-container"), "data-qa": DlNavigationQA.List, children: hasNextPage && isLastRow ? /* @__PURE__ */ jsx(RowLoaderMore, {}) : /* @__PURE__ */ jsx(
+        Row,
+        {
+          mode: this.props.mode,
+          place: this.props.place,
+          displayParentFolder: this.props.displayParentFolder,
+          onEntryContextClick: this.props.onEntryContextClick,
+          onChangeFavorite: this.props.onChangeFavorite,
+          currentEntryContext: this.props.currentEntryContext,
+          currentPageEntry: this.props.currentPageEntry,
+          clickableScope: this.props.clickableScope,
+          inactiveEntryKeys: this.props.inactiveEntryKeys,
+          inactiveEntryIds: this.props.inactiveEntryIds,
+          checkEntryActivity: this.props.checkEntryActivity,
+          onEntryClick: this.props.onEntryClick,
+          onEntryParentClick: this.props.onEntryParentClick,
+          linkWrapper: this.props.linkWrapper,
+          selectedIds: this.props.selectedIds,
+          onEntrySelect: this.props.onEntrySelect,
+          isBatchEnabled: this.props.isBatchEnabled,
+          entry,
+          onMenuClick: this.props.onMenuClick,
+          isOnlyCollectionsMode: this.props.isOnlyCollectionsMode,
+          index: index - 1
+        }
+      ) });
+    };
+    this.getRowHeight = () => {
+      return ROW_HEIGHT;
+    };
+    this.onItemsRendered = ({ visibleStopIndex }) => {
+      const { hasNextPage, entries, loading } = this.props;
+      if (!loading && hasNextPage && entries.length + this.getHeaderItemsCount() === visibleStopIndex) {
+        this.props.onLoadMore();
+      }
+    };
+  }
+  componentDidUpdate(prevProps) {
+    const shouldListUpdate = !(prevProps.loading === this.props.loading && prevProps.currentEntryContext === this.props.currentEntryContext && prevProps.selectedIds === this.props.selectedIds && prevProps.entries === this.props.entries);
+    if (shouldListUpdate && this.listRef.current) {
+      this.listRef.current.forceUpdate();
+    }
+  }
+  render() {
+    const {
+      hasNextPage,
+      entries,
+      showBatchPanel,
+      mode,
+      displayParentFolder,
+      isAllCheckBoxChecked,
+      onAllCheckBoxSelect,
+      isBatchEnabled,
+      isOnlyCollectionsMode
+    } = this.props;
+    const entriesLength = entries.length;
+    const itemCount = (hasNextPage ? entriesLength + 1 : entriesLength) + this.getHeaderItemsCount();
+    return /* @__PURE__ */ jsx(
+      InnerElementTypeContext.Provider,
+      {
+        value: {
+          showBatchPanel,
+          mode,
+          displayParentFolder,
+          isAllCheckBoxChecked,
+          onAllCheckBoxSelect,
+          isBatchEnabled,
+          isOnlyCollectionsMode
+        },
+        children: /* @__PURE__ */ jsx(AutoSizer, { children: ({ width, height }) => /* @__PURE__ */ jsx(
+          VariableSizeList,
+          {
+            ref: this.listRef,
+            innerElementType: InnerElementType,
+            width,
+            height,
+            overscanCount: 10,
+            itemCount,
+            itemSize: this.getRowHeight,
+            onScroll: this.onScroll,
+            onItemsRendered: this.onItemsRendered,
+            children: this.rowRenderer
+          }
+        ) })
+      }
+    );
+  }
+  getHeaderItemsCount() {
+    return this.props.isBatchEnabled ? 1 : 0;
+  }
+}
+function useBatchSelect({
+  entries,
+  mode,
+  isMobileNavigation,
+  onItemSelect
+}) {
+  const isBatchEnabled = checkBatchEnabled(mode, isMobileNavigation);
+  const [selectedIds, setSelectedIds] = React__default.useState(/* @__PURE__ */ new Set());
+  const selectionIndexAnchor = React__default.useRef(null);
+  const allActiveIds = React__default.useMemo(() => {
+    const ids = entries.filter((entry) => !entry.isLocked && !entry.workbookId).map((entry) => entry.entryId);
+    return new Set(ids);
+  }, [entries]);
+  const isAllCheckBoxChecked = React__default.useMemo(() => {
+    return allActiveIds.size > 0 && [...allActiveIds].every((id) => selectedIds.has(id));
+  }, [allActiveIds, selectedIds]);
+  const onAllCheckBoxSelect = React__default.useCallback(() => {
+    const newSelectedIds = isAllCheckBoxChecked ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([...allActiveIds]);
+    setSelectedIds(newSelectedIds);
+    onItemSelect?.({
+      selectedItemsIds: newSelectedIds
+    });
+    selectionIndexAnchor.current = null;
+  }, [isAllCheckBoxChecked, allActiveIds]);
+  const onSelectByShiftKey = React__default.useCallback(
+    (entryId, index, lastCheckedIndex) => {
+      const newSelectedIds = /* @__PURE__ */ new Set([...selectedIds]);
+      const checked = !selectedIds.has(entryId);
+      const start = Math.min(lastCheckedIndex, index);
+      const end = Math.max(lastCheckedIndex, index);
+      for (let i = start; i <= end; i++) {
+        if (allActiveIds.has(entries[i].entryId)) {
+          if (checked) {
+            newSelectedIds.add(entries[i].entryId);
+          } else {
+            newSelectedIds.delete(entries[i].entryId);
+          }
+        }
+      }
+      selectionIndexAnchor.current = index;
+      setSelectedIds(newSelectedIds);
+      onItemSelect?.({
+        selectedItemId: entryId,
+        selectedItemsIds: newSelectedIds
+      });
+    },
+    [allActiveIds, entries, selectedIds]
+  );
+  const onEntrySelect = React__default.useCallback(
+    (entryId, index, { shiftKey }) => {
+      if (allActiveIds.has(entryId)) {
+        if (shiftKey && selectionIndexAnchor.current !== null) {
+          onSelectByShiftKey(entryId, index, selectionIndexAnchor.current);
+          return;
+        }
+        const newSelectedIds = /* @__PURE__ */ new Set([...selectedIds]);
+        if (selectedIds.has(entryId)) {
+          newSelectedIds.delete(entryId);
+        } else {
+          newSelectedIds.add(entryId);
+        }
+        selectionIndexAnchor.current = index;
+        setSelectedIds(newSelectedIds);
+        if (onItemSelect) {
+          onItemSelect({
+            selectedItemId: entryId,
+            selectedItemsIds: newSelectedIds
+          });
+        }
+      }
+    },
+    [allActiveIds, selectedIds]
+  );
+  const resetSelected = React__default.useCallback(() => {
+    setSelectedIds(/* @__PURE__ */ new Set());
+    selectionIndexAnchor.current = null;
+  }, []);
+  return {
+    selectedIds,
+    isBatchEnabled,
+    onEntrySelect,
+    isAllCheckBoxChecked,
+    onAllCheckBoxSelect,
+    resetSelected
+  };
+}
+function checkBatchEnabled(mode, isMobileNavigation) {
+  if (isMobileNavigation || mode === "minimal") {
+    return false;
+  }
+  return true;
+}
+const b$3 = block("dl-core-navigation-table-view");
+const TableView = (props) => {
+  const { isMobileNavigation, onItemSelect, ...listProps } = props;
+  const [batchAction, setBatchAction] = React__default.useState(null);
+  const {
+    selectedIds,
+    isBatchEnabled,
+    onEntrySelect,
+    isAllCheckBoxChecked,
+    onAllCheckBoxSelect,
+    resetSelected
+  } = useBatchSelect({
+    isMobileNavigation,
+    onItemSelect,
+    mode: props.mode,
+    entries: props.entries
+  });
+  const countSelectedIds = selectedIds.size;
+  const showBatchPanel = isBatchEnabled && countSelectedIds > 0;
+  return /* @__PURE__ */ jsxs("div", { className: b$3({ mobile: DL.IS_MOBILE }), children: [
+    /* @__PURE__ */ jsx(
+      List,
+      {
+        ...listProps,
+        selectedIds,
+        isBatchEnabled,
+        onEntrySelect,
+        showBatchPanel,
+        isAllCheckBoxChecked,
+        onAllCheckBoxSelect
+      }
+    ),
+    showBatchPanel && /* @__PURE__ */ jsx(
+      BatchPanel,
+      {
+        count: countSelectedIds,
+        onAction: setBatchAction,
+        className: b$3("batch-panel"),
+        onClose: resetSelected
+      }
+    ),
+    batchAction && /* @__PURE__ */ jsx(
+      BatchDialog,
+      {
+        action: batchAction,
+        onClose: () => setBatchAction(null),
+        selectedIds,
+        entries: props.entries,
+        refreshNavigation: props.refreshNavigation,
+        onChangeLocation: props.onChangeLocation
+      }
+    )
+  ] });
+};
+const b$2 = block("dl-core-navigation");
+const i18n$1 = I18n.keyset("component.navigation.view");
+const mobileTabsItems = [
+  { id: OWNERSHIP.ALL, title: i18n$1("label_mobile-navigation-filters-all") },
+  { id: OWNERSHIP.ONLY_MINE, title: i18n$1("label_mobile-navigation-filters-mine") },
+  { id: OWNERSHIP.FAVORITES, title: i18n$1("label_mobile-navigation-filters-favorites") }
+];
+const MOBILE_PLACES = [MAP_PLACE_TO_SCOPE[PLACE.DASHBOARDS], MAP_PLACE_TO_SCOPE[PLACE.WIDGETS]];
+class NavigationEntries extends React__default.Component {
+  static propTypes = {
+    scope: PropTypes.string,
+    path: PropTypes.string,
+    place: PropTypes.string,
+    mode: PropTypes.string,
+    // used only in mobile navigation
+    defaultPlace: PropTypes.string,
+    clickableScope: PropTypes.string,
+    inactiveEntryKeys: PropTypes.arrayOf(PropTypes.string),
+    currentPageEntry: PropTypes.object,
+    checkEntryActivity: PropTypes.func,
+    linkWrapper: PropTypes.func,
+    onEntryClick: PropTypes.func,
+    onEntryParentClick: PropTypes.func,
+    onChangeFavorite: PropTypes.func,
+    onPlaceChange: PropTypes.func,
+    setBreadCrumbs: PropTypes.func,
+    getContextMenuItems: PropTypes.func,
+    onContextMenuClick: PropTypes.func,
+    focusSearchInput: PropTypes.func,
+    clearSearchInput: PropTypes.func,
+    onItemSelect: PropTypes.func,
+    getPlaceParameters: PropTypes.func.isRequired,
+    inactiveEntryIds: PropTypes.arrayOf(PropTypes.string),
+    isMobileNavigation: PropTypes.bool,
+    isOnlyCollectionsMode: PropTypes.bool,
+    ignoreWorkbookEntries: PropTypes.bool,
+    ignoreSharedEntries: PropTypes.bool,
+    onChangeLocation: PropTypes.func,
+    resolveUsersByIds: PropTypes.func,
+    onPermissionError: PropTypes.func,
+    renderEmptyStateAction: PropTypes.func
+  };
+  static defaultProps = {
+    mode: MODE_FULL,
+    place: PLACE.ROOT,
+    setBreadCrumbs: noop,
+    onChangeLocation: noop,
+    renderEmptyStateAction: noop
+  };
+  static getDerivedStateFromProps(nextProps, prevState) {
+    const { scope, path, place } = nextProps;
+    const needUpdate = !(scope === prevState.scope && path === prevState.path && place === prevState.place);
+    let { searchValue, hasNextPage, page, ownership } = prevState;
+    if (needUpdate) {
+      searchValue = "";
+      hasNextPage = false;
+      page = null;
+    }
+    if (scope !== prevState.scope && scope !== MAP_PLACE_TO_SCOPE[PLACE.FAVORITES]) {
+      ownership = OWNERSHIP.ONLY_MINE;
+    }
+    return {
+      scope,
+      path,
+      place,
+      needUpdate,
+      searchValue,
+      hasNextPage,
+      page,
+      ownership
+    };
+  }
+  constructor(props) {
+    super(props);
+    const settings = new NavigationSettings();
+    const createdBy = settings.getCreatedBy();
+    this.state = {
+      settings,
+      entries: [],
+      filteredEntries: [],
+      orderBy: settings.getOrderBy(),
+      ownership: createdBy ? OWNERSHIP.ONLY_MINE : OWNERSHIP.ALL,
+      currentEntryContextButton: React__default.createRef(),
+      breadCrumbs: [],
+      isEmptyFolder: false
+    };
+    this.debounceGetListDirectory = debounce(this.debounceGetListDirectory, 300);
+    this.showHidden = Boolean(Utils.restore("dlShowHiddenEntries"));
+  }
+  componentDidMount() {
+    this._isMounted = true;
+    this.getListDirectory();
+  }
+  componentDidUpdate() {
+    if (this.state.needUpdate) {
+      if (this.props.clearSearchInput) {
+        this.props.clearSearchInput();
+      }
+      this.getListDirectory();
+    }
+  }
+  componentWillUnmount() {
+    this._isMounted = false;
+  }
+  refSearchInput = React__default.createRef();
+  getFilteredEntries(entries = []) {
+    return entries.filter((entry) => {
+      const hideSharedEntry = entry.collectionId && this.props.ignoreSharedEntries;
+      const showEntry = !hideSharedEntry && (!entry.hidden || this.showHidden);
+      return this.props.isMobileNavigation ? showEntry && MOBILE_PLACES.includes(entry.scope) : showEntry;
+    });
+  }
+  refresh = () => {
+    this.setState(
+      {
+        searchValue: "",
+        hasNextPage: false,
+        page: null
+      },
+      () => {
+        this.getListDirectory();
+      }
+    );
+  };
+  onLoadMore = () => {
+    this.getListDirectory();
+  };
+  changeFavorite(entryId, isFavorite) {
+    const { entries: stateEntries } = this.state;
+    const entryIndex = stateEntries.findIndex((entry) => entry.entryId === entryId);
+    if (entryIndex !== -1) {
+      const entries = [
+        ...stateEntries.slice(0, entryIndex),
+        { ...stateEntries[entryIndex], isFavorite },
+        ...stateEntries.slice(entryIndex + 1)
+      ];
+      const filteredEntries = this.getFilteredEntries(entries);
+      this.setState({ entries, filteredEntries });
+    }
+  }
+  requestList({ isSearch }) {
+    const { scope, path = "", place, getPlaceParameters, ignoreWorkbookEntries } = this.props;
+    const { page: currentPage, searchValue, orderBy } = this.state;
+    const placeParameters = getPlaceParameters(place);
+    let page = currentPage === null ? 0 : currentPage + 1;
+    if (isSearch) {
+      page = 0;
+    }
+    this.setState({ page });
+    return getSdk().sdk.mix.getNavigationList(
+      {
+        place,
+        scope,
+        path: normalizeDestination(path),
+        orderBy,
+        createdBy: this.state.ownership === OWNERSHIP.ONLY_MINE && place !== PLACE.ROOT ? [DL.USER_LOGIN, makeUserId(DL.USER_ID)] : void 0,
+        pageSize: placeParameters.pageSize || 100,
+        page,
+        filters: {
+          name: searchValue
+        },
+        ignoreWorkbookEntries
+      },
+      { concurrentId: "getNavigationList" }
+    );
+  }
+  handlePermissionDenied = () => {
+  };
+  async getListDirectory({ isSearch, ignoreEmpty, isPermissionRetry } = {}) {
+    const { path, place, setBreadCrumbs, onPermissionError } = this.props;
+    const { isEmptyFolder, searchValue } = this.state;
+    if (ignoreEmpty && isEmptyFolder) {
+      return;
+    }
+    this.setState({
+      error: null,
+      loading: true,
+      hasNextPage: isSearch ? false : this.state.hasNextPage
+    });
+    try {
+      const {
+        hasNextPage,
+        entries: requestEntries,
+        breadCrumbs
+      } = await this.requestList({
+        isSearch
+      });
+      if (requestEntries.length) {
+        const ids = filterUsersIds(requestEntries.map((entry) => entry.createdBy));
+        this.props.resolveUsersByIds(ids);
+      }
+      if (hasNextPage && requestEntries.length === 0) {
+        this.getListDirectory();
+        return;
+      }
+      if (!isSearch) {
+        setBreadCrumbs(breadCrumbs);
+      }
+      const entries = this.state.hasNextPage && !isSearch ? [...this.state.entries, ...requestEntries] : requestEntries;
+      const filteredEntries = this.getFilteredEntries(entries);
+      if (path === this.props.path && place === this.props.place && this._isMounted) {
+        this.setState({
+          loading: false,
+          entries,
+          filteredEntries,
+          hasNextPage,
+          breadCrumbs,
+          isEmptyFolder: searchValue ? isEmptyFolder : filteredEntries.length === 0
+        });
+      }
+      if (this.refSearchInput.current) {
+        this.refSearchInput.current.focus();
+      }
+      if (this.props.focusSearchInput) {
+        this.props.focusSearchInput();
+      }
+    } catch (error) {
+      if (getSdk().sdk.isCancel(error)) {
+        return;
+      }
+      if (error.status === 403 && !isPermissionRetry) {
+        onPermissionError?.();
+        this.setState({ page: null });
+        this.getListDirectory({ isPermissionRetry: true });
+        return;
+      }
+      logger.logError("NavigationEntries: getListDirectory failed", error);
+      if (this._isMounted) {
+        this.setState({
+          loading: false,
+          error,
+          breadCrumbs: this.cutBreadCrubms(path, place)
+        });
+      }
+    }
+  }
+  cutBreadCrubms(path, place) {
+    const { breadCrumbs } = this.state;
+    if (place !== PLACE.ROOT) {
+      return breadCrumbs;
+    }
+    const normalizedPath = normalizeDestination(path).toLowerCase();
+    const index = breadCrumbs.findIndex(
+      (breadCrumb) => breadCrumb.path.toLowerCase() === normalizedPath
+    );
+    if (index === -1) {
+      return breadCrumbs;
+    } else {
+      const result = breadCrumbs.slice(0, index + 1);
+      this.props.setBreadCrumbs(result);
+      return result;
+    }
+  }
+  onChangeFavorite = async (entry) => {
+    const { path } = this.props;
+    const { entryId, isFavorite } = entry;
+    this.changeFavorite(entryId, !isFavorite);
+    try {
+      if (isFavorite) {
+        await getSdk().sdk.us.deleteFavorite({ entryId });
+      } else {
+        await getSdk().sdk.us.addFavorite({ entryId });
+      }
+      if (this.props.onChangeFavorite) {
+        this.props.onChangeFavorite({ entryId, isFavorite: !isFavorite });
+      }
+    } catch (error) {
+      logger.logError("NavigationEntries: onChangeFavorite failed", error);
+      if (path === this.props.path) {
+        this.changeFavorite(entryId, isFavorite);
+        this.props.showToast({
+          title: isFavorite ? i18n$1("toast_failed-remove-favorite") : i18n$1("toast_failed-add-favorite"),
+          name: "ChangeFavoriteFailed",
+          error
+        });
+      }
+    }
+  };
+  onEntryContextClick = ({ entry, buttonRef }) => {
+    const isVisible = !this.state.currentEntryContext || this.state.currentEntryContext.entryId !== entry.entryId;
+    this.setState({
+      currentEntryContextButton: isVisible ? buttonRef : React__default.createRef(),
+      currentEntryContext: isVisible ? entry : null
+    });
+  };
+  closeEntryContextMenu = () => {
+    this.setState({
+      currentEntryContextButton: React__default.createRef(),
+      currentEntryContext: null
+    });
+  };
+  debounceGetListDirectory({ isSearch, ignoreEmpty }) {
+    this.getListDirectory({ isSearch, ignoreEmpty });
+  }
+  onChangeFilter = (searchValue) => {
+    const filteredEntries = this.getFilteredEntries(this.state.entries);
+    this.setState(
+      {
+        searchValue,
+        filteredEntries
+      },
+      () => {
+        this.debounceGetListDirectory({ isSearch: true, ignoreEmpty: true });
+      }
+    );
+  };
+  onChangeOrderBy = (orderBy) => {
+    if (this.props.mode !== MODE_MINIMAL) {
+      this.state.settings.setOrderBy(orderBy.field, orderBy.direction);
+    }
+    this.setState(
+      {
+        orderBy,
+        hasNextPage: false,
+        page: null
+      },
+      () => {
+        this.getListDirectory({ ignoreEmpty: true });
+      }
+    );
+  };
+  onChangeOwnership = (ownership) => {
+    if (this.props.mode !== MODE_MINIMAL) {
+      this.state.settings.setCreatedBy(
+        ownership === OWNERSHIP.ONLY_MINE ? DL.USER_LOGIN : ""
+      );
+    }
+    this.setState(
+      {
+        ownership,
+        hasNextPage: false,
+        page: null
+      },
+      () => {
+        this.getListDirectory();
+      }
+    );
+  };
+  onAllDashboardsFilterClick = () => {
+    this.setState(
+      {
+        ownership: OWNERSHIP.ALL,
+        hasNextPage: false,
+        page: null
+      },
+      () => {
+        if (this.props.place !== PLACE.DASHBOARDS) {
+          this.props.onPlaceChange(PLACE.DASHBOARDS);
+        } else {
+          this.getListDirectory();
+        }
+      }
+    );
+  };
+  onOnlyMineDashboardsFilterClick = () => {
+    this.setState(
+      {
+        ownership: OWNERSHIP.ONLY_MINE,
+        hasNextPage: false,
+        page: null
+      },
+      () => {
+        if (this.props.place !== PLACE.DASHBOARDS) {
+          this.props.onPlaceChange(PLACE.DASHBOARDS);
+        } else {
+          this.getListDirectory();
+        }
+      }
+    );
+  };
+  onFavoritesDashboardsFilterClick = () => {
+    this.setState(
+      {
+        ownership: OWNERSHIP.ALL,
+        hasNextPage: false,
+        page: null
+      },
+      () => {
+        this.props.onPlaceChange(PLACE.FAVORITES);
+      }
+    );
+  };
+  onSelectTab = (tabId) => {
+    const { onPlaceChange, defaultPlace } = this.props;
+    this.setState(
+      {
+        ownership: tabId,
+        hasNextPage: false,
+        page: null
+      },
+      () => {
+        if (tabId === OWNERSHIP.ONLY_MINE || tabId === OWNERSHIP.ALL) {
+          onPlaceChange(defaultPlace || PLACE.DASHBOARDS);
+          this.getListDirectory();
+          return;
+        }
+        onPlaceChange(PLACE.FAVORITES);
+      }
+    );
+  };
+  renderEntriesHeader() {
+    const { mode } = this.props;
+    const { place } = this.state;
+    const { filters } = this.props.getPlaceParameters(place);
+    const isMinimalMode = mode === MODE_MINIMAL;
+    if (!filters && isMinimalMode) {
+      return null;
+    }
+    return /* @__PURE__ */ React__default.createElement("div", { className: b$2("entries-header") }, /* @__PURE__ */ React__default.createElement("div", { className: b$2("search") }, /* @__PURE__ */ React__default.createElement(
+      SearchInput,
+      {
+        ref: this.refSearchInput,
+        text: this.state.searchValue,
+        placeholder: i18n$1("label_placeholder-filter-by-name"),
+        onChange: this.onChangeFilter
+      }
+    )), filters && /* @__PURE__ */ React__default.createElement("div", { className: b$2("filters") }, filters.order && /* @__PURE__ */ React__default.createElement("div", { className: b$2("filters-item") }, /* @__PURE__ */ React__default.createElement(
+      OrderSelect,
+      {
+        orderBy: this.state.orderBy,
+        onChange: this.onChangeOrderBy
+      }
+    )), filters.ownership && /* @__PURE__ */ React__default.createElement("div", { className: b$2("filters-item") }, /* @__PURE__ */ React__default.createElement(
+      SegmentedRadioGroup,
+      {
+        value: this.state.ownership,
+        onUpdate: this.onChangeOwnership,
+        options: [
+          {
+            value: OWNERSHIP.ALL,
+            content: i18n$1("value_ownership-all")
+          },
+          {
+            value: OWNERSHIP.ONLY_MINE,
+            content: i18n$1("value_ownership-only-mine")
+          }
+        ]
+      }
+    ))), /* @__PURE__ */ React__default.createElement("div", { className: b$2("custom") }, this.props.children));
+  }
+  renderFiltersForMobileNavigationPage() {
+    const { ownership } = this.state;
+    return /* @__PURE__ */ React__default.createElement("div", null, /* @__PURE__ */ React__default.createElement("div", { className: b$2("mobile-filters", { mobile: DL.IS_MOBILE }) }, /* @__PURE__ */ React__default.createElement(
+      DataLensTabs,
+      {
+        items: mobileTabsItems,
+        activeTab: ownership,
+        size: MOBILE_SIZE.TABS,
+        onSelectTab: this.onSelectTab
+      }
+    )));
+  }
+  renderLoader() {
+    return /* @__PURE__ */ React__default.createElement("div", { className: b$2("spinner") }, /* @__PURE__ */ React__default.createElement(Loader, { size: "l" }));
+  }
+  renderContextMenu() {
+    return this.state.currentEntryContextButton.current && /* @__PURE__ */ React__default.createElement(
+      EntryContextMenuBase,
+      {
+        visible: true,
+        entry: this.state.currentEntryContext,
+        anchorElement: this.state.currentEntryContextButton.current,
+        items: this.props.getContextMenuItems({
+          entry: this.state.currentEntryContext,
+          place: this.state.place
+        }),
+        onMenuClick: this.props.onContextMenuClick,
+        onClose: this.closeEntryContextMenu
+      }
+    );
+  }
+  renderView() {
+    const { place, entries, filteredEntries, currentEntryContext, isEmptyFolder } = this.state;
+    const { mode } = this.props;
+    const filteredEntriesEmpty = filteredEntries.length === 0;
+    const entriesEmpty = entries.length === 0;
+    const showEmpty = filteredEntriesEmpty || entriesEmpty;
+    if (showEmpty) {
+      return /* @__PURE__ */ React__default.createElement(
+        EmptyState,
+        {
+          className: b$2("empty-entries"),
+          mode,
+          isEmptyFolder,
+          place,
+          renderAction: this.props.renderEmptyStateAction
+        }
+      );
+    }
+    const { displayParentFolder } = this.props.getPlaceParameters(place);
+    return /* @__PURE__ */ React__default.createElement("div", { className: b$2("table-view") }, /* @__PURE__ */ React__default.createElement(
+      TableView,
+      {
+        linkWrapper: this.props.linkWrapper,
+        mode: this.props.mode,
+        place,
+        clickableScope: this.props.clickableScope,
+        inactiveEntryKeys: this.props.inactiveEntryKeys,
+        currentPageEntry: this.props.currentPageEntry,
+        checkEntryActivity: this.props.checkEntryActivity,
+        entries: filteredEntries,
+        inactiveEntryIds: this.props.inactiveEntryIds,
+        currentEntryContext,
+        displayParentFolder: !this.props.isMobileNavigation && displayParentFolder,
+        onChangeFavorite: this.onChangeFavorite,
+        onEntryContextClick: this.onEntryContextClick,
+        onCloseEntryContextMenu: this.closeEntryContextMenu,
+        onEntryParentClick: this.props.onEntryParentClick,
+        onEntryClick: this.props.onEntryClick,
+        loading: this.state.loading,
+        hasNextPage: this.state.hasNextPage,
+        onLoadMore: this.onLoadMore,
+        isMobileNavigation: this.props.isMobileNavigation,
+        isOnlyCollectionsMode: this.props.isOnlyCollectionsMode,
+        refreshNavigation: this.refresh,
+        onChangeLocation: this.props.onChangeLocation,
+        onMenuClick: this.props.onContextMenuClick,
+        onItemSelect: this.props.onItemSelect
+      }
+    ));
+  }
+  render() {
+    const { isMobileNavigation } = this.props;
+    const { loading, error, hasNextPage } = this.state;
+    if (error) {
+      return /* @__PURE__ */ React__default.createElement(ErrorView, { error, onRetryClick: this.refresh });
+    }
+    return /* @__PURE__ */ React__default.createElement("div", { className: b$2("entries") }, isMobileNavigation ? this.renderFiltersForMobileNavigationPage() : this.renderEntriesHeader(), /* @__PURE__ */ React__default.createElement("div", { className: b$2("view") }, loading && !hasNextPage ? this.renderLoader() : this.renderView(), this.renderContextMenu()));
+  }
+}
+const mapDispatchToProps = {
+  // need to be wrapped in additional function because the registry function does not have time to register
+  resolveUsersByIds: (ids) => getResolveUsersByIdsAction()(ids),
+  showToast
+};
+var NavigationEntries_default = connect(null, mapDispatchToProps, null, { forwardRef: true })(NavigationEntries);
+const i18n = I18n.keyset("component.navigation.view");
+const b$1 = block("dl-core-navigation-minimal");
+class NavigationMinimal extends React__default.Component {
+  static propTypes = {
+    anchor: PropTypes.any,
+    popupPlacement: PropTypes.array,
+    hasTail: PropTypes.bool,
+    visible: PropTypes.bool,
+    path: PropTypes.string,
+    className: PropTypes.string,
+    clickableScope: PropTypes.string,
+    onClose: PropTypes.func,
+    onChooseFolder: PropTypes.func,
+    onCreateFolderClick: PropTypes.func,
+    onCrumbClick: PropTypes.func,
+    getPlaceParameters: PropTypes.func.isRequired,
+    placeSelectNode: PropTypes.element,
+    place: PropTypes.string,
+    onPermissionError: PropTypes.func
+  };
+  static defaultProps = {
+    hasTail: false,
+    popupPlacement: ["bottom-start"],
+    onChooseFolder: noop,
+    place: PLACE.ROOT
+  };
+  static getDerivedStateFromProps(props, state) {
+    const { visible } = props;
+    if (props.visible === state.visible) {
+      return null;
+    }
+    return {
+      visible
+    };
+  }
+  state = {
+    breadCrumbs: []
+  };
+  refEntries = React__default.createRef();
+  refresh() {
+    if (this.refEntries.current) {
+      this.refEntries.current.refresh();
+    }
+  }
+  onClose = (event) => {
+    if (document.body.contains(event.target)) {
+      this.props.onClose(event);
+    }
+  };
+  onChooseFolder = (event) => {
+    if (!this.refEntries.current.state.isLoading) {
+      this.props.onChooseFolder(this.props.path);
+      this.props.onClose(event);
+    }
+  };
+  setBreadCrumbs = (breadCrumbs) => {
+    if (!isEqual(this.state.breadCrumbs, breadCrumbs)) {
+      this.setState({ breadCrumbs });
+    }
+  };
+  renderFooter() {
+    const { breadCrumbs } = this.state;
+    const lastBreadCrumb = breadCrumbs[breadCrumbs.length - 1];
+    const canEditInCurrentFolder = breadCrumbs.length === 0 || Boolean(
+      lastBreadCrumb && lastBreadCrumb.permissions && lastBreadCrumb.permissions.edit === true
+    );
+    const isNavPlace = this.props.place === PLACE.ROOT;
+    const disabledAccept = !isNavPlace || !canEditInCurrentFolder;
+    const hasIconLock = isNavPlace && !canEditInCurrentFolder;
+    return /* @__PURE__ */ React__default.createElement("div", { className: b$1("footer") }, this.props.onCreateFolderClick && /* @__PURE__ */ React__default.createElement(
+      Button,
+      {
+        className: b$1("footer-button"),
+        view: "outlined",
+        size: "l",
+        onClick: this.props.onCreateFolderClick
+      },
+      i18n("button_create-folder")
+    ), /* @__PURE__ */ React__default.createElement("div", { className: b$1("footer-navigation-actions") }, /* @__PURE__ */ React__default.createElement(
+      Button,
+      {
+        className: b$1("footer-button"),
+        view: "flat",
+        size: "l",
+        onClick: this.onClose
+      },
+      i18n("button_cancel")
+    ), /* @__PURE__ */ React__default.createElement(
+      Button,
+      {
+        className: b$1("footer-button"),
+        view: "action",
+        size: "l",
+        onClick: this.onChooseFolder,
+        disabled: disabledAccept,
+        qa: DlNavigationQA.MinimalDoneBtn
+      },
+      hasIconLock && /* @__PURE__ */ React__default.createElement(Icon, { data: Lock }),
+      i18n("button_done")
+    )));
+  }
+  render() {
+    const { popupPlacement, anchor, visible, hasTail, clickableScope, className } = this.props;
+    if (!anchor.current) {
+      return null;
+    }
+    const hasButtonsChoose = clickableScope === Scope.Folder;
+    return /* @__PURE__ */ React__default.createElement(
+      Popup,
+      {
+        hasArrow: hasTail,
+        placement: popupPlacement,
+        onOpenChange: (open, event) => {
+          if (!open) {
+            this.onClose(event);
+          }
+        },
+        open: visible,
+        anchorElement: anchor.current
+      },
+      visible && /* @__PURE__ */ React__default.createElement("div", { className: b$1(null, className), "data-qa": DlNavigationQA.NavigationMinimal }, this.props.place === PLACE.ROOT && /* @__PURE__ */ React__default.createElement("div", { className: b$1("header") }, /* @__PURE__ */ React__default.createElement("div", { className: b$1("controls") }, /* @__PURE__ */ React__default.createElement(
+        NavigationBreadcrumbs,
+        {
+          breadCrumbs: this.state.breadCrumbs,
+          place: this.props.place,
+          getPlaceParameters: this.props.getPlaceParameters,
+          onClick: this.props.onCrumbClick,
+          enableMenu: false
+        }
+      ))), this.props.placeSelectNode, /* @__PURE__ */ React__default.createElement(
+        NavigationEntries_default,
+        {
+          ref: this.refEntries,
+          ...this.props,
+          mode: MODE_MINIMAL,
+          getPlaceParameters: this.props.getPlaceParameters,
+          setBreadCrumbs: this.setBreadCrumbs,
+          onPermissionError: this.props.onPermissionError
+        }
+      ), hasButtonsChoose && this.renderFooter())
+    );
+  }
+}
+var NavigationMinimal_default$1 = NavigationMinimal;
+const b = block("dl-navigation-minimal-place-select");
+class PlaceSelect extends React__default.PureComponent {
+  static propTypes = {
+    place: PropTypes.string,
+    path: PropTypes.string,
+    items: PropTypes.arrayOf(PropTypes.string),
+    quickItems: PropTypes.arrayOf(PropTypes.string),
+    onChange: PropTypes.func
+  };
+  _getItemsConfig() {
+    const { items } = this.props;
+    const { getNavigationPlacesConfig } = registry.common.functions.getAll();
+    const placesConfig = getNavigationPlacesConfig();
+    return items.map((item) => getPlaceConfig({ place: item, placesConfig }));
+  }
+  _getQuickItemsConfig() {
+    const { quickItems } = this.props;
+    const { getNavigationQuickItems } = registry.common.functions.getAll();
+    const config = getNavigationQuickItems();
+    return quickItems.map((key) => config.find((itemConfig) => itemConfig.key === key));
+  }
+  _getFullConfig() {
+    const { quickItems } = this.props;
+    const itemsConfig = this._getItemsConfig();
+    return quickItems ? itemsConfig.concat(this._getQuickItemsConfig()) : itemsConfig;
+  }
+  _getQuickItem() {
+    const { path, quickItems } = this.props;
+    if (!quickItems) {
+      return null;
+    }
+    return this._getQuickItemsConfig().find((itemConfig) => itemConfig.key === path);
+  }
+  _getSelectItems() {
+    return this._getFullConfig().map(({ place, text, icon, key, iconClassName, qa }) => {
+      return {
+        value: place || key,
+        content: /* @__PURE__ */ React__default.createElement("div", { className: b("option"), "data-qa": "navigation-minimal-place-select-option" }, /* @__PURE__ */ React__default.createElement(Icon, { data: icon, className: iconClassName, size: "16" }), /* @__PURE__ */ React__default.createElement("div", { "data-qa": qa, className: b("option-text") }, text))
+      };
+    });
+  }
+  _onChange = ([value]) => {
+    const { key } = this._getFullConfig().find(
+      ({ place, key: key2 }) => place === value || key2 === value
+    );
+    this.props.onChange({
+      path: key,
+      root: key ? PLACE.ROOT : value
+    });
+  };
+  renderOption(option) {
+    return option.content;
+  }
+  render() {
+    const { place } = this.props;
+    const quickItem = this._getQuickItem();
+    return /* @__PURE__ */ React__default.createElement("div", { className: b() }, /* @__PURE__ */ React__default.createElement(
+      Select,
+      {
+        qa: "navigation-minimal-place-select",
+        popupClassName: b("popup"),
+        className: b("select"),
+        options: this._getSelectItems(),
+        value: quickItem ? [quickItem.key] : [place],
+        onUpdate: this._onChange,
+        renderOption: this.renderOption,
+        renderSelectedOption: this.renderOption
+      }
+    ));
+  }
+}
+async function getEntryKey(entryId, defaultPath) {
+  try {
+    const { key } = await getSdk().sdk.us.getEntry({ entryId });
+    return key;
+  } catch (error) {
+    logger.logError("resolveNavigationPath: getEntry failed", error);
+    return defaultPath;
+  }
+}
+const resolveNavigationPath = (Component) => {
+  function ResolveNavigationPath(props) {
+    const { startFrom, visible, resolvePathMode } = props;
+    const [state, setState] = React__default.useState({});
+    React__default.useEffect(() => {
+      async function setPath(origin = DL.USER_FOLDER) {
+        let path = "";
+        let root = PLACE.ROOT;
+        const { extractEntryId } = registry.common.functions.getAll();
+        const possibleEntryId = extractEntryId(origin);
+        if (resolvePathMode) {
+          switch (resolvePathMode) {
+            case "place":
+              root = origin;
+              break;
+            case "key":
+              path = origin;
+              break;
+            case "id":
+              path = await getEntryKey(resolvePathMode, path);
+              break;
+            default:
+              throw new Error("unknown resolvePathMode");
+          }
+        } else if (possibleEntryId && !startFrom.endsWith("/")) {
+          path = await getEntryKey(possibleEntryId, path);
+        } else if (PLACE_VALUES.includes(origin)) {
+          root = origin;
+        } else {
+          path = origin;
+        }
+        setState({ ...state, resolvedPath: path, resolvedRoot: root });
+      }
+      setPath(startFrom);
+    }, [startFrom, resolvePathMode]);
+    return "resolvedPath" in state && visible ? /* @__PURE__ */ React__default.createElement(Component, { ...props, path: state.resolvedPath, root: state.resolvedRoot }) : null;
+  }
+  ResolveNavigationPath.propTypes = {
+    startFrom: PropTypes.string,
+    sdk: PropTypes.object,
+    visible: PropTypes.bool,
+    resolvePathMode: PropTypes.string
+  };
+  return ResolveNavigationPath;
+};
+class NavigationMinimalService extends React__default.PureComponent {
+  static propTypes = {
+    path: PropTypes.string,
+    root: PropTypes.string,
+    sdk: PropTypes.object,
+    onClose: PropTypes.func,
+    anchor: PropTypes.any,
+    onEntryClick: PropTypes.func,
+    clickableScope: PropTypes.string,
+    includeClickableType: PropTypes.oneOfType([
+      PropTypes.string,
+      PropTypes.arrayOf(PropTypes.string)
+    ]),
+    excludeClickableType: PropTypes.oneOfType([
+      PropTypes.string,
+      PropTypes.arrayOf(PropTypes.string)
+    ]),
+    placeSelectParameters: PropTypes.shape({
+      items: PropTypes.array.isRequired,
+      quickItems: PropTypes.array
+    }),
+    inactiveEntryIds: PropTypes.arrayOf(PropTypes.string),
+    ignoreWorkbookEntries: PropTypes.bool,
+    ignoreSharedEntries: PropTypes.bool,
+    canCreateFolder: PropTypes.bool
+  };
+  static defaultProps = {
+    onClose: noop,
+    onEntryClick: noop,
+    root: PLACE.ROOT
+  };
+  static getDerivedStateFromProps(props, state) {
+    const { path, root } = props;
+    if (path === state.initialPath && root === state.initialRoot) {
+      return null;
+    } else {
+      return {
+        path,
+        root,
+        initialPath: path,
+        initialRoot: root
+      };
+    }
+  }
+  state = {};
+  refDialogues = React__default.createRef();
+  refNavigation = React__default.createRef();
+  preventClose = false;
+  refresh() {
+    if (this.refNavigation.current) {
+      this.refNavigation.current.refresh();
+    }
+  }
+  onClose = (event) => {
+    const { anchor } = this.props;
+    if (this.preventClose) {
+      return;
+    }
+    if (anchor.current && !anchor.current.contains(event.target) || event instanceof KeyboardEvent && event.code === "Escape") {
+      this.props.onClose(event);
+    }
+  };
+  onEntryClick = (entry, event) => {
+    if (entry.isLocked) {
+      this.unlockEntry(entry);
+      return;
+    }
+    if (entry.scope !== "folder") {
+      this.props.onEntryClick(entry, event);
+      return;
+    }
+    this.setState({
+      path: entry.key,
+      root: PLACE.ROOT
+    });
+  };
+  onEntryParentClick = (entry) => {
+    this.onCrumbClick({ path: entry.key });
+  };
+  onCrumbClick = (crumb, event, last) => {
+    if (last) {
+      this.refresh();
+    } else {
+      this.setState({
+        path: crumb.path,
+        root: PLACE.ROOT
+      });
+    }
+  };
+  onPlaceSelectChange = ({ path, root }) => {
+    this.setState({
+      path,
+      root
+    });
+  };
+  onPermissionError = () => {
+    this.setState({
+      path: void 0,
+      root: PLACE.ROOT
+    });
+  };
+  async unlockEntry(entry) {
+    this.preventClose = true;
+    await this.refDialogues.current.open({
+      dialog: EntryDialogName.Unlock,
+      dialogProps: { entry }
+    });
+    this.preventClose = false;
+  }
+  getInitialCreateDestination = () => {
+    const { path } = this.state;
+    const { getInitDestination: getInitDestination2 } = registry.common.functions.getAll();
+    return getInitDestination2(path);
+  };
+  createFolderClick = async () => {
+    this.preventClose = true;
+    const response = await this.refDialogues.current.open({
+      dialog: EntryDialogName.CreateFolder,
+      dialogProps: {
+        initDestination: this.getInitialCreateDestination()
+      }
+    });
+    if (response.status === EntryDialogResolveStatus.Success) {
+      this.refNavigation.current.refresh();
+    }
+    this.preventClose = false;
+  };
+  render() {
+    const { includeClickableType, excludeClickableType, placeSelectParameters, ...props } = this.props;
+    const placeSelectNode = placeSelectParameters ? /* @__PURE__ */ React__default.createElement(
+      PlaceSelect,
+      {
+        place: this.state.root,
+        path: this.state.path,
+        items: placeSelectParameters.items,
+        quickItems: placeSelectParameters.quickItems,
+        onChange: this.onPlaceSelectChange
+      }
+    ) : null;
+    const { getNavigationPlacesConfig } = registry.common.functions.getAll();
+    const getPlaceParameters = (place) => {
+      return getPlaceConfig({ place, placesConfig: getNavigationPlacesConfig() });
+    };
+    return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, /* @__PURE__ */ React__default.createElement(
+      NavigationMinimal_default$1,
+      {
+        ...props,
+        checkEntryActivity: checkEntryActivity(
+          this.props.clickableScope,
+          includeClickableType,
+          excludeClickableType
+        ),
+        onClose: this.onClose,
+        path: this.state.path,
+        place: this.state.root,
+        onCreateFolderClick: this.props.canCreateFolder ? this.createFolderClick : void 0,
+        onEntryClick: this.onEntryClick,
+        onEntryParentClick: this.onEntryParentClick,
+        onCrumbClick: this.onCrumbClick,
+        ref: this.refNavigation,
+        getPlaceParameters,
+        placeSelectNode,
+        ignoreWorkbookEntries: this.props.ignoreWorkbookEntries,
+        ignoreSharedEntries: this.props.ignoreSharedEntries,
+        onPermissionError: this.onPermissionError
+      }
+    ), /* @__PURE__ */ React__default.createElement(EntryDialogues, { ref: this.refDialogues, sdk: this.props.sdk }));
+  }
+}
+var NavigationMinimal_default = resolveNavigationPath(NavigationMinimalService);
+const getInitDestination = (path) => {
+  const destination = DL.USER_FOLDER;
+  return !path || path === ROOT_PATH ? destination : path;
+};
+export {
+  NavigationMinimal_default as N,
+  QUICK_ITEMS as Q,
+  getPlacesConfig as a,
+  getCreatableEntriesConfig as b,
+  getQuickItems as c,
+  getInitDestination as d,
+  getPlaceSelectParameters as e,
+  getPathDisplayName as g
+};