ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/containers/Storage/Storage.tsx

@@ -1,240 +0,0 @@
-import {useCallback, useEffect} from 'react';
-import {useDispatch} from 'react-redux';
-
-import {AccessDenied} from '../../components/Errors/403';
-import {TableWithControlsLayout} from '../../components/TableWithControlsLayout/TableWithControlsLayout';
-import {ResponseError} from '../../components/Errors/ResponseError';
-
-import type {
-    StorageSortParams,
-    StorageType,
-    VisibleEntities,
-} from '../../store/reducers/storage/types';
-import type {NodesSortParams} from '../../store/reducers/nodes/types';
-import type {AdditionalNodesProps} from '../../types/additionalProps';
-import {
-    setInitialState,
-    setVisibleEntities,
-    setStorageTextFilter,
-    setUsageFilter,
-    setStorageType,
-    setNodesUptimeFilter,
-    setDataWasNotLoaded,
-    getStorageNodesInfo,
-    getStorageGroupsInfo,
-    setNodesSortParams,
-    setGroupsSortParams,
-} from '../../store/reducers/storage/storage';
-import {
-    selectFilteredGroups,
-    selectFilteredNodes,
-    selectEntitiesCount,
-    selectUsageFilterOptions,
-    selectNodesSortParams,
-    selectGroupsSortParams,
-} from '../../store/reducers/storage/selectors';
-import {VISIBLE_ENTITIES, STORAGE_TYPES} from '../../store/reducers/storage/constants';
-import {getNodesList, selectNodesMap} from '../../store/reducers/nodesList';
-import {
-    useAutofetcher,
-    useNodesRequestParams,
-    useStorageRequestParams,
-    useTableSort,
-    useTypedSelector,
-} from '../../utils/hooks';
-import {NodesUptimeFilterValues} from '../../utils/nodes';
-import {DEFAULT_TABLE_SETTINGS} from '../../utils/constants';
-
-import {StorageGroups} from './StorageGroups/StorageGroups';
-import {StorageNodes} from './StorageNodes/StorageNodes';
-import {StorageControls} from './StorageControls/StorageControls';
-import {b} from './shared';
-
-import './Storage.scss';
-
-interface StorageProps {
-    additionalNodesProps?: AdditionalNodesProps;
-    tenant?: string;
-    nodeId?: string;
-}
-
-export const Storage = ({additionalNodesProps, tenant, nodeId}: StorageProps) => {
-    const dispatch = useDispatch();
-
-    const {autorefresh} = useTypedSelector((state) => state.schema);
-    const {
-        loading,
-        wasLoaded,
-        error,
-        type,
-        visible: visibleEntities,
-        filter,
-        usageFilter,
-        nodesUptimeFilter,
-    } = useTypedSelector((state) => state.storage);
-    const storageNodes = useTypedSelector(selectFilteredNodes);
-    const storageGroups = useTypedSelector(selectFilteredGroups);
-    const entitiesCount = useTypedSelector(selectEntitiesCount);
-    const nodesMap = useTypedSelector(selectNodesMap);
-    const usageFilterOptions = useTypedSelector(selectUsageFilterOptions);
-    const nodesSortParams = useTypedSelector(selectNodesSortParams);
-    const groupsSortParams = useTypedSelector(selectGroupsSortParams);
-
-    // Do not display Nodes table for Node page (NodeId present)
-    const isNodePage = nodeId !== undefined;
-    const storageType = isNodePage ? STORAGE_TYPES.groups : type;
-
-    useEffect(() => {
-        dispatch(getNodesList());
-
-        return () => {
-            // Clean data on component unmount
-            dispatch(setInitialState());
-        };
-    }, [dispatch]);
-
-    const nodesRequestParams = useNodesRequestParams({
-        filter,
-        nodesUptimeFilter,
-        ...nodesSortParams,
-    });
-    const storageRequestParams = useStorageRequestParams({
-        filter,
-        ...groupsSortParams,
-    });
-
-    const [nodesSort, handleNodesSort] = useTableSort(nodesSortParams, (params) =>
-        dispatch(setNodesSortParams(params as NodesSortParams)),
-    );
-    const [groupsSort, handleGroupsSort] = useTableSort(groupsSortParams, (params) =>
-        dispatch(setGroupsSortParams(params as StorageSortParams)),
-    );
-
-    const fetchData = useCallback(
-        (isBackground: boolean) => {
-            if (!isBackground) {
-                dispatch(setDataWasNotLoaded());
-            }
-
-            const nodesParams = nodesRequestParams || {};
-            const storageParams = storageRequestParams || {};
-
-            if (storageType === STORAGE_TYPES.nodes) {
-                dispatch(getStorageNodesInfo({tenant, visibleEntities, ...nodesParams}));
-            } else {
-                dispatch(getStorageGroupsInfo({tenant, visibleEntities, nodeId, ...storageParams}));
-            }
-        },
-        [
-            dispatch,
-            tenant,
-            nodeId,
-            visibleEntities,
-            storageType,
-            storageRequestParams,
-            nodesRequestParams,
-        ],
-    );
-
-    const autorefreshEnabled = tenant ? autorefresh : true;
-
-    useAutofetcher(fetchData, [fetchData], autorefreshEnabled);
-
-    const handleUsageFilterChange = (value: string[]) => {
-        dispatch(setUsageFilter(value));
-    };
-
-    const handleTextFilterChange = (value: string) => {
-        dispatch(setStorageTextFilter(value));
-    };
-
-    const handleGroupVisibilityChange = (value: VisibleEntities) => {
-        dispatch(setVisibleEntities(value));
-    };
-
-    const handleStorageTypeChange = (value: StorageType) => {
-        dispatch(setStorageType(value));
-    };
-
-    const handleUptimeFilterChange = (value: NodesUptimeFilterValues) => {
-        dispatch(setNodesUptimeFilter(value));
-    };
-
-    const handleShowAllNodes = () => {
-        handleGroupVisibilityChange(VISIBLE_ENTITIES.all);
-        handleUptimeFilterChange(NodesUptimeFilterValues.All);
-    };
-
-    const renderDataTable = () => {
-        return (
-            <>
-                {storageType === STORAGE_TYPES.groups && (
-                    <StorageGroups
-                        visibleEntities={visibleEntities}
-                        data={storageGroups}
-                        tableSettings={DEFAULT_TABLE_SETTINGS}
-                        nodes={nodesMap}
-                        onShowAll={() => handleGroupVisibilityChange(VISIBLE_ENTITIES.all)}
-                        sort={groupsSort}
-                        handleSort={handleGroupsSort}
-                    />
-                )}
-                {storageType === STORAGE_TYPES.nodes && (
-                    <StorageNodes
-                        visibleEntities={visibleEntities}
-                        nodesUptimeFilter={nodesUptimeFilter}
-                        data={storageNodes}
-                        tableSettings={DEFAULT_TABLE_SETTINGS}
-                        onShowAll={handleShowAllNodes}
-                        additionalNodesProps={additionalNodesProps}
-                        sort={nodesSort}
-                        handleSort={handleNodesSort}
-                    />
-                )}
-            </>
-        );
-    };
-
-    const renderControls = () => {
-        return (
-            <StorageControls
-                searchValue={filter}
-                handleSearchValueChange={handleTextFilterChange}
-                withTypeSelector={!isNodePage}
-                storageType={storageType}
-                handleStorageTypeChange={handleStorageTypeChange}
-                visibleEntities={visibleEntities}
-                handleVisibleEntitiesChange={handleGroupVisibilityChange}
-                nodesUptimeFilter={nodesUptimeFilter}
-                handleNodesUptimeFilterChange={handleUptimeFilterChange}
-                groupsUsageFilter={usageFilter}
-                groupsUsageFilterOptions={usageFilterOptions}
-                handleGroupsUsageFilterChange={handleUsageFilterChange}
-                entitiesCountCurrent={
-                    storageType === STORAGE_TYPES.groups
-                        ? storageGroups.length
-                        : storageNodes.length
-                }
-                entitiesCountTotal={entitiesCount.total}
-                entitiesLoading={loading && !wasLoaded}
-            />
-        );
-    };
-
-    if (error) {
-        if (error.status === 403) {
-            return <AccessDenied position="left" />;
-        }
-
-        return <ResponseError error={error} />;
-    }
-
-    return (
-        <TableWithControlsLayout>
-            <TableWithControlsLayout.Controls>{renderControls()}</TableWithControlsLayout.Controls>
-            <TableWithControlsLayout.Table loading={loading && !wasLoaded} className={b('table')}>
-                {renderDataTable()}
-            </TableWithControlsLayout.Table>
-        </TableWithControlsLayout>
-    );
-};

package/dist/containers/Storage/StorageControls/StorageControls.tsx

@@ -1,104 +0,0 @@
-import {EntitiesCount} from '../../../components/EntitiesCount/EntitiesCount';
-import {Search} from '../../../components/Search/Search';
-import {UptimeFilter} from '../../../components/UptimeFIlter';
-
-import type {StorageType, VisibleEntities} from '../../../store/reducers/storage/types';
-import {STORAGE_TYPES} from '../../../store/reducers/storage/constants';
-import {NodesUptimeFilterValues} from '../../../utils/nodes';
-
-import {UsageFilter, type UsageFilterItem} from '../UsageFilter/UsageFilter';
-import {StorageTypeFilter} from '../StorageTypeFilter/StorageTypeFilter';
-import {StorageVisibleEntitiesFilter} from '../StorageVisibleEntitiesFilter/StorageVisibleEntitiesFilter';
-import i18n from '../i18n';
-import {b} from '../shared';
-
-interface StorageControlsProps {
-    searchValue?: string;
-    handleSearchValueChange: (value: string) => void;
-
-    withTypeSelector?: boolean;
-    storageType: StorageType;
-    handleStorageTypeChange: (value: StorageType) => void;
-
-    visibleEntities: VisibleEntities;
-    handleVisibleEntitiesChange: (value: VisibleEntities) => void;
-
-    nodesUptimeFilter: NodesUptimeFilterValues;
-    handleNodesUptimeFilterChange: (value: NodesUptimeFilterValues) => void;
-
-    withGroupsUsageFilter?: boolean;
-    groupsUsageFilter?: string[];
-    groupsUsageFilterOptions?: UsageFilterItem[];
-    handleGroupsUsageFilterChange?: (value: string[]) => void;
-
-    entitiesCountCurrent: number;
-    entitiesCountTotal?: number;
-    entitiesLoading: boolean;
-}
-
-export const StorageControls = ({
-    searchValue,
-    handleSearchValueChange,
-
-    withTypeSelector,
-    storageType,
-    handleStorageTypeChange,
-
-    visibleEntities,
-    handleVisibleEntitiesChange,
-
-    nodesUptimeFilter,
-    handleNodesUptimeFilterChange,
-
-    withGroupsUsageFilter,
-    groupsUsageFilter,
-    groupsUsageFilterOptions,
-    handleGroupsUsageFilterChange,
-
-    entitiesCountCurrent,
-    entitiesCountTotal,
-    entitiesLoading,
-}: StorageControlsProps) => {
-    const isNodes = storageType === STORAGE_TYPES.nodes;
-    const entityName = isNodes ? i18n('nodes') : i18n('groups');
-
-    return (
-        <>
-            <Search
-                value={searchValue}
-                onChange={handleSearchValueChange}
-                placeholder={
-                    isNodes
-                        ? i18n('controls_nodes-search-placeholder')
-                        : i18n('controls_groups-search-placeholder')
-                }
-                className={b('search')}
-            />
-            {withTypeSelector && (
-                <StorageTypeFilter value={storageType} onChange={handleStorageTypeChange} />
-            )}
-            <StorageVisibleEntitiesFilter
-                value={visibleEntities}
-                onChange={handleVisibleEntitiesChange}
-            />
-
-            {isNodes && (
-                <UptimeFilter value={nodesUptimeFilter} onChange={handleNodesUptimeFilterChange} />
-            )}
-            {!isNodes && withGroupsUsageFilter && (
-                <UsageFilter
-                    value={groupsUsageFilter}
-                    onChange={handleGroupsUsageFilterChange}
-                    groups={groupsUsageFilterOptions}
-                />
-            )}
-
-            <EntitiesCount
-                label={entityName}
-                loading={entitiesLoading}
-                total={entitiesCountTotal}
-                current={entitiesCountCurrent}
-            />
-        </>
-    );
-};

package/dist/containers/Storage/StorageGroups/StorageGroups.tsx

@@ -1,59 +0,0 @@
-import {useMemo} from 'react';
-
-import DataTable, {Settings, SortOrder} from '@gravity-ui/react-data-table';
-
-import type {NodesMap} from '../../../types/store/nodesList';
-import type {PreparedStorageGroup, VisibleEntities} from '../../../store/reducers/storage/types';
-import type {HandleSort} from '../../../utils/hooks/useTableSort';
-import {VISIBLE_ENTITIES} from '../../../store/reducers/storage/constants';
-import {getPreparedStorageGroupsColumns} from './getStorageGroupsColumns';
-import {StorageGroupsEmptyDataMessage} from './StorageGroupsEmptyDataMessage';
-
-import i18n from './i18n';
-import './StorageGroups.scss';
-
-interface StorageGroupsProps {
-    data: PreparedStorageGroup[];
-    nodes?: NodesMap;
-    tableSettings: Settings;
-    visibleEntities: VisibleEntities;
-    onShowAll?: VoidFunction;
-    sort?: SortOrder;
-    handleSort?: HandleSort;
-}
-
-export function StorageGroups({
-    data,
-    tableSettings,
-    visibleEntities,
-    nodes,
-    onShowAll,
-    sort,
-    handleSort,
-}: StorageGroupsProps) {
-    const columns = useMemo(() => {
-        return getPreparedStorageGroupsColumns(nodes, visibleEntities);
-    }, [nodes, visibleEntities]);
-
-    if (!data.length && visibleEntities !== VISIBLE_ENTITIES.all) {
-        return (
-            <StorageGroupsEmptyDataMessage
-                onShowAll={onShowAll}
-                visibleEntities={visibleEntities}
-            />
-        );
-    }
-
-    return (
-        <DataTable
-            key={visibleEntities}
-            theme="yandex-cloud"
-            data={data}
-            columns={columns}
-            settings={tableSettings}
-            emptyDataMessage={i18n('empty.default')}
-            sortOrder={sort}
-            onSort={handleSort}
-        />
-    );
-}

package/dist/containers/Storage/StorageGroups/StorageGroupsEmptyDataMessage.tsx

@@ -1,30 +0,0 @@
-import type {VisibleEntities} from '../../../store/reducers/storage/types';
-import {VISIBLE_ENTITIES} from '../../../store/reducers/storage/constants';
-import {EmptyFilter} from '../EmptyFilter/EmptyFilter';
-import i18n from './i18n';
-
-interface StorageNodesEmptyDataMessageProps {
-    visibleEntities?: VisibleEntities;
-    onShowAll?: VoidFunction;
-}
-
-export const StorageGroupsEmptyDataMessage = ({
-    visibleEntities,
-    onShowAll,
-}: StorageNodesEmptyDataMessageProps) => {
-    let message;
-
-    if (visibleEntities === VISIBLE_ENTITIES.space) {
-        message = i18n('empty.out_of_space');
-    }
-
-    if (visibleEntities === VISIBLE_ENTITIES.missing) {
-        message = i18n('empty.degraded');
-    }
-
-    if (message) {
-        return <EmptyFilter title={message} showAll={i18n('show_all')} onShowAll={onShowAll} />;
-    }
-
-    return null;
-};

package/dist/containers/Storage/StorageGroups/VirtualStorageGroups.tsx

@@ -1,94 +0,0 @@
-import {useCallback, useMemo} from 'react';
-
-import type {NodesMap} from '../../../types/store/nodesList';
-import type {StorageSortValue} from '../../../utils/storage';
-import {
-    VirtualTable,
-    type FetchData,
-    type RenderControls,
-    type RenderErrorMessage,
-} from '../../../components/VirtualTable';
-import type {PreparedStorageGroup, VisibleEntities} from '../../../store/reducers/storage/types';
-import {VISIBLE_ENTITIES} from '../../../store/reducers/storage/constants';
-
-import {StorageGroupsEmptyDataMessage} from './StorageGroupsEmptyDataMessage';
-import {getPreparedStorageGroupsColumns} from './getStorageGroupsColumns';
-import {getStorageGroups} from './getGroups';
-import i18n from './i18n';
-
-interface VirtualStorageGroupsProps {
-    searchValue: string;
-    visibleEntities: VisibleEntities;
-    tenant?: string;
-    nodeId?: string;
-    nodesMap?: NodesMap;
-
-    onShowAll: VoidFunction;
-
-    parentContainer?: Element | null;
-    renderControls: RenderControls;
-    renderErrorMessage: RenderErrorMessage;
-}
-
-export const VirtualStorageGroups = ({
-    searchValue,
-    visibleEntities,
-    tenant,
-    nodeId,
-    nodesMap,
-    onShowAll,
-    parentContainer,
-    renderControls,
-    renderErrorMessage,
-}: VirtualStorageGroupsProps) => {
-    const filters = useMemo(() => {
-        return [searchValue, visibleEntities, tenant, nodeId];
-    }, [searchValue, visibleEntities, tenant, nodeId]);
-
-    const fetchData = useCallback<FetchData<PreparedStorageGroup>>(
-        async (limit, offset, {sortOrder, columnId} = {}) => {
-            return await getStorageGroups({
-                limit,
-                offset,
-                filter: searchValue,
-                visibleEntities,
-                tenant,
-                nodeId,
-
-                sortOrder,
-                sortValue: columnId as StorageSortValue,
-            });
-        },
-        [nodeId, searchValue, tenant, visibleEntities],
-    );
-
-    const columns = useMemo(() => {
-        return getPreparedStorageGroupsColumns(nodesMap, visibleEntities);
-    }, [nodesMap, visibleEntities]);
-
-    const renderEmptyDataMessage = () => {
-        if (visibleEntities !== VISIBLE_ENTITIES.all) {
-            return (
-                <StorageGroupsEmptyDataMessage
-                    onShowAll={onShowAll}
-                    visibleEntities={visibleEntities}
-                />
-            );
-        }
-
-        return i18n('empty.default');
-    };
-
-    return (
-        <VirtualTable
-            parentContainer={parentContainer}
-            columns={columns}
-            fetchData={fetchData}
-            limit={50}
-            renderControls={renderControls}
-            renderErrorMessage={renderErrorMessage}
-            renderEmptyDataMessage={renderEmptyDataMessage}
-            dependencyArray={filters}
-        />
-    );
-};

package/dist/containers/Storage/StorageGroups/getGroups.ts

@@ -1,21 +0,0 @@
-import type {StorageApiRequestParams} from '../../../store/reducers/storage/types';
-import {prepareStorageGroupsResponse} from '../../../store/reducers/storage/utils';
-import {EVersion} from '../../../types/api/storage';
-
-const getConcurrentId = (limit?: number, offset?: number) => {
-    return `getStorageGroups|offset${offset}|limit${limit}`;
-};
-
-export const getStorageGroups = async ({limit, offset, ...params}: StorageApiRequestParams) => {
-    const response = await window.api.getStorageInfo(
-        {version: EVersion.v2, limit, offset, ...params},
-        {concurrentId: getConcurrentId(limit, offset)},
-    );
-    const preparedResponse = prepareStorageGroupsResponse(response);
-
-    return {
-        data: preparedResponse.groups || [],
-        found: preparedResponse.found || 0,
-        total: preparedResponse.total || 0,
-    };
-};