ydb-ui-components 3.6.0 → 4.0.0

package/build/esm/components/NavigationTree/NavigationTreeNode.js

@@ -1,153 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { NavigationTreeActionType } from './state';
+import { TreeView } from '../TreeView/TreeView';
+import { ColumnTableIcon } from '../icons/ColumnTable';
 import { DatabaseIcon } from '../icons/Database';
+import { ExternalDataSourceIcon } from '../icons/ExternalDataSource';
+import { ExternalTableIcon } from '../icons/ExternalTable';
 import { FolderIcon } from '../icons/Folder';
 import { FolderOpenIcon } from '../icons/FolderOpen';
+import { IndexIcon } from '../icons/Index';
 import { TableIcon } from '../icons/Table';
 import { TopicIcon } from '../icons/Topic';
-import { IndexIcon } from '../icons/Index';
-import { ColumnTableIcon } from '../icons/ColumnTable';
-import { ExternalTableIcon } from '../icons/ExternalTable';
-import { ExternalDataSourceIcon } from '../icons/ExternalDataSource';
-import { TreeView } from '../TreeView/TreeView';
-
+import { NavigationTreeActionType } from './state';
 function renderIcon(type, collapsed) {
-  switch (type) {
-    case 'database':
-      // this icon is larger than the others, therefore 14 for a better fit
-      return /*#__PURE__*/React.createElement(DatabaseIcon, {
-        height: 14
-      });
-
-    case 'directory':
-      return collapsed ? /*#__PURE__*/React.createElement(FolderIcon, {
-        height: 16
-      }) : /*#__PURE__*/React.createElement(FolderOpenIcon, {
-        height: 16
-      });
-
-    case 'index':
-      return /*#__PURE__*/React.createElement(IndexIcon, {
-        height: 16
-      });
-
-    case 'table':
-    case 'index_table':
-      return /*#__PURE__*/React.createElement(TableIcon, {
-        height: 16
-      });
-
-    case 'column_table':
-      return /*#__PURE__*/React.createElement(ColumnTableIcon, {
-        height: 16
-      });
-
-    case 'stream':
-    case 'topic':
-      return /*#__PURE__*/React.createElement(TopicIcon, {
-        height: 16
-      });
-
-    case 'external_table':
-      return /*#__PURE__*/React.createElement(ExternalTableIcon, {
-        height: 16
-      });
-
-    case 'external_data_source':
-      return /*#__PURE__*/React.createElement(ExternalDataSourceIcon, {
-        height: 16
-      });
-
-    default:
-      return null;
-  }
+    switch (type) {
+        case 'database':
+            // this icon is larger than the others, therefore 14 for a better fit
+            return _jsx(DatabaseIcon, { height: 14 });
+        case 'directory':
+            return collapsed ? _jsx(FolderIcon, { height: 16 }) : _jsx(FolderOpenIcon, { height: 16 });
+        case 'index':
+            return _jsx(IndexIcon, { height: 16 });
+        case 'table':
+        case 'index_table':
+            return _jsx(TableIcon, { height: 16 });
+        case 'column_table':
+            return _jsx(ColumnTableIcon, { height: 16 });
+        case 'stream':
+        case 'topic':
+            return _jsx(TopicIcon, { height: 16 });
+        case 'external_table':
+            return _jsx(ExternalTableIcon, { height: 16 });
+        case 'external_data_source':
+            return _jsx(ExternalDataSourceIcon, { height: 16 });
+        default:
+            return null;
+    }
 }
-
-export function NavigationTreeNode(_ref) {
-  var path = _ref.path,
-      fetchPath = _ref.fetchPath,
-      activePath = _ref.activePath,
-      state = _ref.state,
-      level = _ref.level,
-      dispatch = _ref.dispatch,
-      children = _ref.children,
-      onActivate = _ref.onActivate,
-      getActions = _ref.getActions,
-      renderAdditionalNodeElements = _ref.renderAdditionalNodeElements,
-      cache = _ref.cache;
-  var nodeState = state[path];
-  React.useEffect(function () {
-    if (nodeState.collapsed) {
-      if (!cache) {
+export function NavigationTreeNode({ path, fetchPath, activePath, state, level, dispatch, children, onActivate, getActions, renderAdditionalNodeElements, cache, }) {
+    const nodeState = state[path];
+    React.useEffect(() => {
+        if (nodeState.collapsed) {
+            if (!cache) {
+                dispatch({
+                    type: NavigationTreeActionType.ResetNode,
+                    payload: { path },
+                });
+            }
+            return;
+        }
+        if (nodeState.loaded || nodeState.loading) {
+            return;
+        }
         dispatch({
-          type: NavigationTreeActionType.ResetNode,
-          payload: {
-            path: path
-          }
+            type: NavigationTreeActionType.StartLoading,
+            payload: { path },
         });
-      }
-
-      return;
-    }
-
-    if (nodeState.loaded || nodeState.loading) {
-      return;
-    }
-
-    dispatch({
-      type: NavigationTreeActionType.StartLoading,
-      payload: {
-        path: path
-      }
-    });
-    fetchPath(path).then(function (data) {
-      dispatch({
-        type: NavigationTreeActionType.FinishLoading,
-        payload: {
-          path: path,
-          activePath: activePath,
-          data: data
-        }
-      });
-    })["catch"](function (error) {
-      dispatch({
-        type: NavigationTreeActionType.FinishLoading,
-        payload: {
-          path: path,
-          error: error
+        fetchPath(path)
+            .then((data) => {
+            dispatch({
+                type: NavigationTreeActionType.FinishLoading,
+                payload: { path, activePath, data },
+            });
+        })
+            .catch((error) => {
+            dispatch({
+                type: NavigationTreeActionType.ErrorLoading,
+                payload: { path, error },
+            });
+        });
+    }, [nodeState.collapsed]);
+    const handleClick = React.useCallback(() => {
+        if (onActivate) {
+            onActivate(path);
         }
-      });
-    });
-  }, [nodeState.collapsed]);
-  var handleClick = React.useCallback(function () {
-    if (onActivate) {
-      onActivate(path);
-    }
-  }, [path, onActivate]);
-  var handleArrowClick = React.useCallback(function () {
-    dispatch({
-      type: NavigationTreeActionType.ToggleCollapsed,
-      payload: {
-        path: path
-      }
-    });
-  }, []);
-  var additionalNodeElements = React.useMemo(function () {
-    return renderAdditionalNodeElements === null || renderAdditionalNodeElements === void 0 ? void 0 : renderAdditionalNodeElements(nodeState.path, nodeState.type);
-  }, [renderAdditionalNodeElements, nodeState]);
-  var actions = React.useMemo(function () {
-    return getActions === null || getActions === void 0 ? void 0 : getActions(nodeState.path, nodeState.type);
-  }, [getActions, nodeState]);
-  return /*#__PURE__*/React.createElement(TreeView, {
-    name: nodeState.name,
-    icon: renderIcon(nodeState.type, nodeState.collapsed),
-    collapsed: nodeState.collapsed,
-    active: nodeState.path === activePath,
-    actions: actions,
-    additionalNodeElements: additionalNodeElements,
-    hasArrow: nodeState.expandable,
-    onClick: handleClick,
-    onArrowClick: handleArrowClick,
-    level: level
-  }, children);
-}
+    }, [path, onActivate]);
+    const handleArrowClick = React.useCallback(() => {
+        dispatch({ type: NavigationTreeActionType.ToggleCollapsed, payload: { path } });
+    }, [dispatch, path]);
+    const additionalNodeElements = React.useMemo(() => {
+        return renderAdditionalNodeElements === null || renderAdditionalNodeElements === void 0 ? void 0 : renderAdditionalNodeElements(nodeState.path, nodeState.type);
+    }, [renderAdditionalNodeElements, nodeState]);
+    const actions = React.useMemo(() => {
+        return getActions === null || getActions === void 0 ? void 0 : getActions(nodeState.path, nodeState.type);
+    }, [getActions, nodeState]);
+    return (_jsx(TreeView, { name: nodeState.name, icon: renderIcon(nodeState.type, nodeState.collapsed), collapsed: nodeState.collapsed, active: nodeState.path === activePath, actions: actions, additionalNodeElements: additionalNodeElements, hasArrow: nodeState.expandable, onClick: handleClick, onArrowClick: handleArrowClick, level: level, children: children }));
+}

package/build/esm/components/NavigationTree/i18n/index.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (key: string, params?: import("@gravity-ui/i18n").Params | undefined) => string;
+declare const _default: (key: "label_error" | "label_empty", params?: import("@gravity-ui/i18n").Params | undefined) => string;
 export default _default;

package/build/esm/components/NavigationTree/i18n/index.js

@@ -1,8 +1,5 @@
-import { i18n } from '../../i18n';
-import { Lang } from '../../../utils';
+import { addComponentKeysets } from '@gravity-ui/uikit/i18n';
 import en from './en.json';
 import ru from './ru.json';
-var COMPONENT = 'ydb-navigation-tree';
-i18n.registerKeyset(Lang.En, COMPONENT, en);
-i18n.registerKeyset(Lang.Ru, COMPONENT, ru);
-export default i18n.keyset(COMPONENT);
+const COMPONENT = 'ydb-navigation-tree';
+export default addComponentKeysets({ en, ru }, COMPONENT);

package/build/esm/components/NavigationTree/index.d.ts

@@ -1,2 +1,2 @@
 export * from './NavigationTree';
-export * from './types';
+export type * from './types';

package/build/esm/components/NavigationTree/index.js

@@ -1,2 +1 @@
 export * from './NavigationTree';
-export * from './types';

package/build/esm/components/NavigationTree/state.d.ts

@@ -1,14 +1,40 @@
-import type { NavigationTreeNodeState, NavigationTreeNodePartialState, NavigationTreeState, NavigationTreeServiceNode } from './types';
+import type { NavigationTreeDataItem, NavigationTreeNodePartialState, NavigationTreeNodeState, NavigationTreeServiceNode, NavigationTreeState } from './types';
 export declare enum NavigationTreeActionType {
     ToggleCollapsed = "toggle-collapsed",
     StartLoading = "start-loading",
     FinishLoading = "finish-loading",
+    ErrorLoading = "error-loading",
     ResetNode = "reset-node"
 }
-export interface NavigationTreeAction {
-    type: NavigationTreeActionType;
-    payload: any;
-}
+export type NavigationTreeAction = {
+    type: NavigationTreeActionType.ToggleCollapsed;
+    payload: {
+        path: string;
+    };
+} | {
+    type: NavigationTreeActionType.StartLoading;
+    payload: {
+        path: string;
+    };
+} | {
+    type: NavigationTreeActionType.FinishLoading;
+    payload: {
+        path: string;
+        activePath?: string;
+        data: NavigationTreeDataItem[];
+    };
+} | {
+    type: NavigationTreeActionType.ErrorLoading;
+    payload: {
+        path: string;
+        error: unknown;
+    };
+} | {
+    type: NavigationTreeActionType.ResetNode;
+    payload: {
+        path: string;
+    };
+};
 export declare function getDefaultNodeState(): {
     collapsed: boolean;
     loading: boolean;

package/build/esm/components/NavigationTree/state.js

@@ -1,118 +1,63 @@
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 import { getServiceNode, traverseDFS } from './utils';
 export var NavigationTreeActionType;
-
 (function (NavigationTreeActionType) {
-  NavigationTreeActionType["ToggleCollapsed"] = "toggle-collapsed";
-  NavigationTreeActionType["StartLoading"] = "start-loading";
-  NavigationTreeActionType["FinishLoading"] = "finish-loading";
-  NavigationTreeActionType["ResetNode"] = "reset-node";
+    NavigationTreeActionType["ToggleCollapsed"] = "toggle-collapsed";
+    NavigationTreeActionType["StartLoading"] = "start-loading";
+    NavigationTreeActionType["FinishLoading"] = "finish-loading";
+    NavigationTreeActionType["ErrorLoading"] = "error-loading";
+    NavigationTreeActionType["ResetNode"] = "reset-node";
 })(NavigationTreeActionType || (NavigationTreeActionType = {}));
-
 export function getDefaultNodeState() {
-  return {
-    collapsed: true,
-    loading: false,
-    loaded: false,
-    error: false,
-    children: []
-  };
+    return {
+        collapsed: true,
+        loading: false,
+        loaded: false,
+        error: false,
+        children: [],
+    };
 }
 export function getNodeState(partialState) {
-  return _objectSpread(_objectSpread({}, getDefaultNodeState()), {}, {
-    expandable: partialState.type === 'database' || partialState.type === 'directory'
-  }, partialState);
+    return Object.assign(Object.assign(Object.assign({}, getDefaultNodeState()), { expandable: partialState.type === 'database' || partialState.type === 'directory' }), partialState);
 }
-export function reducer() {
-  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var action = arguments.length > 1 ? arguments[1] : undefined;
-
-  switch (action.type) {
-    case NavigationTreeActionType.ToggleCollapsed:
-      return _objectSpread(_objectSpread({}, state), {}, _defineProperty({}, action.payload.path, _objectSpread(_objectSpread({}, state[action.payload.path]), {}, {
-        collapsed: !state[action.payload.path].collapsed
-      })));
-
-    case NavigationTreeActionType.StartLoading:
-      return _objectSpread(_objectSpread({}, state), {}, _defineProperty({}, action.payload.path, _objectSpread(_objectSpread({}, state[action.payload.path]), {}, {
-        loading: true,
-        loaded: false,
-        error: false,
-        children: []
-      })));
-
-    case NavigationTreeActionType.FinishLoading:
-      {
-        var newState = _objectSpread(_objectSpread({}, state), {}, _defineProperty({}, action.payload.path, _objectSpread(_objectSpread({}, state[action.payload.path]), {}, {
-          loading: false,
-          loaded: Boolean(action.payload.data),
-          error: Boolean(action.payload.error)
-        })));
-
-        if (action.payload.data) {
-          newState[action.payload.path].children = action.payload.data.map(function (_ref) {
-            var name = _ref.name;
-            return name;
-          });
-
-          var _iterator = _createForOfIteratorHelper(action.payload.data),
-              _step;
-
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              var _state$path$collapsed, _state$path;
-
-              var item = _step.value;
-              var path = "".concat(action.payload.path, "/").concat(item.name); // expand the tree according to the active path
-              // prioritize the existing state to expand the tree only on first load
-
-              var _action$payload$activ = action.payload.activePath,
-                  activePath = _action$payload$activ === void 0 ? '' : _action$payload$activ;
-              var collapsed = (_state$path$collapsed = (_state$path = state[path]) === null || _state$path === void 0 ? void 0 : _state$path.collapsed) !== null && _state$path$collapsed !== void 0 ? _state$path$collapsed : !activePath.startsWith("".concat(path, "/"));
-              newState[path] = getNodeState(_objectSpread(_objectSpread({}, item), {}, {
-                collapsed: collapsed,
-                path: path
-              }));
+export function reducer(state = {}, action) {
+    var _a, _b;
+    switch (action.type) {
+        case NavigationTreeActionType.ToggleCollapsed:
+            return Object.assign(Object.assign({}, state), { [action.payload.path]: Object.assign(Object.assign({}, state[action.payload.path]), { collapsed: !state[action.payload.path].collapsed }) });
+        case NavigationTreeActionType.StartLoading:
+            return Object.assign(Object.assign({}, state), { [action.payload.path]: Object.assign(Object.assign({}, state[action.payload.path]), { loading: true, loaded: false, error: false, children: [] }) });
+        case NavigationTreeActionType.FinishLoading: {
+            const newState = Object.assign(Object.assign({}, state), { [action.payload.path]: Object.assign(Object.assign({}, state[action.payload.path]), { loading: false, loaded: Boolean(action.payload.data), error: false }) });
+            if (action.payload.data) {
+                newState[action.payload.path].children = action.payload.data.map(({ name }) => name);
+                for (const item of action.payload.data) {
+                    const path = `${action.payload.path}/${item.name}`;
+                    // expand the tree according to the active path
+                    // prioritize the existing state to expand the tree only on first load
+                    const { activePath = '' } = action.payload;
+                    const collapsed = (_b = (_a = state[path]) === null || _a === void 0 ? void 0 : _a.collapsed) !== null && _b !== void 0 ? _b : !activePath.startsWith(`${path}/`);
+                    newState[path] = getNodeState(Object.assign(Object.assign({}, item), { collapsed,
+                        path }));
+                }
             }
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
-          }
+            return newState;
         }
-
-        return newState;
-      }
-
-    case NavigationTreeActionType.ResetNode:
-      return _objectSpread(_objectSpread({}, state), {}, _defineProperty({}, action.payload.path, _objectSpread(_objectSpread({}, state[action.payload.path]), getDefaultNodeState())));
-
-    default:
-      return state;
-  }
+        case NavigationTreeActionType.ErrorLoading:
+            return Object.assign(Object.assign({}, state), { [action.payload.path]: Object.assign(Object.assign({}, state[action.payload.path]), { loading: false, loaded: false, error: true }) });
+        case NavigationTreeActionType.ResetNode:
+            return Object.assign(Object.assign({}, state), { [action.payload.path]: Object.assign(Object.assign({}, state[action.payload.path]), getDefaultNodeState()) });
+        default:
+            return state;
+    }
 }
 export function selectTreeAsList(state, rootPath) {
-  var list = [];
-  traverseDFS(state, rootPath, function (node, level) {
-    list.push(_objectSpread(_objectSpread({}, node), {}, {
-      level: level
-    }));
-    var serviceNode = getServiceNode(node, level);
-
-    if (serviceNode) {
-      list.push(serviceNode);
-    }
-  });
-  return list;
-}
+    const list = [];
+    traverseDFS(state, rootPath, (node, level) => {
+        list.push(Object.assign(Object.assign({}, node), { level }));
+        const serviceNode = getServiceNode(node, level);
+        if (serviceNode) {
+            list.push(serviceNode);
+        }
+    });
+    return list;
+}

package/build/esm/components/NavigationTree/types.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-import { DropdownMenuItemMixed } from '@gravity-ui/uikit';
-export declare type NavigationTreeNodeType = 'database' | 'directory' | 'table' | 'column_table' | 'index_table' | 'index' | 'topic' | 'stream' | 'external_table' | 'external_data_source';
+import type { DropdownMenuItemMixed } from '@gravity-ui/uikit';
+export type NavigationTreeNodeType = 'database' | 'directory' | 'table' | 'column_table' | 'index_table' | 'index' | 'topic' | 'stream' | 'external_table' | 'external_data_source';
 export interface NavigationTreeDataItem {
     name: string;
     type: NavigationTreeNodeType;
@@ -28,7 +28,7 @@ export interface NavigationTreeServiceNode {
     status: 'loading' | 'error' | 'empty';
     level?: number;
 }
-export declare type NavigationTreeNodePartialState = Omit<NavigationTreeNodeState, 'loading' | 'loaded' | 'error' | 'children'>;
+export type NavigationTreeNodePartialState = Omit<NavigationTreeNodeState, 'loading' | 'loaded' | 'error' | 'children'>;
 export interface NavigationTreeProps<D = any> {
     rootState: NavigationTreeNodePartialState;
     fetchPath: (path: string) => Promise<NavigationTreeDataItem[]>;

package/build/esm/components/NavigationTree/types.js

@@ -1 +1 @@
-export {};
+export {};

package/build/esm/components/NavigationTree/utils.d.ts

@@ -1,6 +1,6 @@
 import type { NavigationTreeNodeState, NavigationTreeServiceNode, NavigationTreeState } from './types';
 export declare function isServiceNode(node: NavigationTreeNodeState | NavigationTreeServiceNode): node is NavigationTreeServiceNode;
 export declare function getServiceNode(node: NavigationTreeNodeState, level: number): NavigationTreeServiceNode | void;
-declare type TraverseDFSVisit = (node: NavigationTreeNodeState, level: number, path: string, state: NavigationTreeState) => void;
+type TraverseDFSVisit = (node: NavigationTreeNodeState, level: number, path: string, state: NavigationTreeState) => void;
 export declare function traverseDFS(state: NavigationTreeState, path: string, visit: TraverseDFSVisit, level?: number): void;
 export {};

package/build/esm/components/NavigationTree/utils.js

@@ -1,68 +1,43 @@
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
 export function isServiceNode(node) {
-  return 'status' in node;
+    return 'status' in node;
 }
 export function getServiceNode(node, level) {
-  if (node.collapsed) {
+    if (node.collapsed) {
+        return undefined;
+    }
+    if (node.loading) {
+        return {
+            path: node.path,
+            status: 'loading',
+            level: level + 1,
+        };
+    }
+    if (node.error) {
+        return {
+            path: node.path,
+            status: 'error',
+            level: level + 1,
+        };
+    }
+    if (node.loaded && node.children.length === 0) {
+        return {
+            path: node.path,
+            status: 'empty',
+            level: level + 1,
+        };
+    }
     return undefined;
-  }
-
-  if (node.loading) {
-    return {
-      path: node.path,
-      status: 'loading',
-      level: level + 1
-    };
-  }
-
-  if (node.error) {
-    return {
-      path: node.path,
-      status: 'error',
-      level: level + 1
-    };
-  }
-
-  if (node.loaded && node.children.length === 0) {
-    return {
-      path: node.path,
-      status: 'empty',
-      level: level + 1
-    };
-  }
-
-  return undefined;
 }
-export function traverseDFS(state, path, visit) {
-  var level = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-  var currentNode = state[path];
-
-  if (!currentNode) {
-    return;
-  }
-
-  visit(currentNode, level, path, state);
-
-  if (currentNode.collapsed) {
-    return;
-  }
-
-  var _iterator = _createForOfIteratorHelper(currentNode.children),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var childPath = _step.value;
-      traverseDFS(state, "".concat(path, "/").concat(childPath), visit, level + 1);
+export function traverseDFS(state, path, visit, level = 0) {
+    const currentNode = state[path];
+    if (!currentNode) {
+        return;
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-}
+    visit(currentNode, level, path, state);
+    if (currentNode.collapsed) {
+        return;
+    }
+    for (const childPath of currentNode.children) {
+        traverseDFS(state, `${path}/${childPath}`, visit, level + 1);
+    }
+}

package/build/esm/components/TreeView/TreeView.d.ts

@@ -1,6 +1,6 @@
-import { DropdownMenuItemMixed } from '@gravity-ui/uikit';
 import React from 'react';
-import './TreeView.scss';
+import type { DropdownMenuItemMixed } from '@gravity-ui/uikit';
+import './TreeView.css';
 export interface TreeViewProps {
     children?: React.ReactNode;
     name: React.ReactNode;