@openshift-assisted/ui-lib 2.9.0-cim → 2.9.6-cim

package/lib/ocm/components/newFeatureSupportLevels/ReviewClusterNewFeatureSupportLevels.tsx

@@ -1,186 +0,0 @@
-import { CheckCircleIcon, InfoCircleIcon } from '@patternfly/react-icons';
-import React from 'react';
-import { global_success_color_100 as okColor } from '@patternfly/react-tokens';
-import { Text, TextList, TextListItem, TextContent } from '@patternfly/react-core';
-import {
-  FeatureId,
-  FeatureIdToSupportLevel,
-  PreviewSupportLevel,
-  isPreviewSupportLevel,
-} from '../../../common/types';
-import { TECH_SUPPORT_LEVEL_LINK } from '../../../common/config/constants';
-import ExternalLink from '../../../common/components/ui/ExternalLink';
-import { Cluster } from '../../../common/api/types';
-import { DetailItem } from '../../../common';
-import { getLimitedFeatureSupportLevels } from '../../../common/components/newFeatureSupportLevels/utils';
-import { WithErrorBoundary } from '../../../common/components/ErrorHandling/WithErrorBoundary';
-import { useTranslation } from '../../../common/hooks/use-translation-wrapper';
-import useOpenshiftVersions from '../../hooks/useOpenshiftVersions';
-import { TFunction } from 'i18next';
-import {
-  NewFeatureSupportLevelData,
-  useNewFeatureSupportLevel,
-} from '../../../common/components/newFeatureSupportLevels';
-
-const getFeatureReviewText = (featureId: FeatureId): string => {
-  switch (featureId) {
-    case 'SNO':
-      return 'Install single node OpenShift (SNO)';
-    case 'VIP_AUTO_ALLOC':
-      return 'Allocate IPs via DHCP server';
-    case 'ARM64_ARCHITECTURE':
-      return 'Use ARM architecture for the cluster';
-    default:
-      return featureId;
-  }
-};
-
-const getPreviewSupportLevelTitle = (supportLevel: PreviewSupportLevel) => {
-  if (supportLevel === 'dev-preview') {
-    return 'Developer Preview Features';
-  }
-  return <ExternalLink href={TECH_SUPPORT_LEVEL_LINK}>Technology Preview Features</ExternalLink>;
-};
-
-const getPreviewFeatureList = (supportLevelMap: FeatureIdToSupportLevel) => {
-  const previewSupportLevels: { [key in PreviewSupportLevel]: FeatureId[] } = {
-    'tech-preview': [],
-    'dev-preview': [],
-  };
-  for (const [featureId, supportLevel] of Object.entries(supportLevelMap)) {
-    if (!isPreviewSupportLevel(supportLevel)) {
-      continue;
-    }
-    previewSupportLevels[supportLevel].push(featureId as FeatureId);
-  }
-  let supportLevel: PreviewSupportLevel;
-  //Show only one preview support level list, first priority to developer preview features
-  if (previewSupportLevels['dev-preview'].length) {
-    supportLevel = 'dev-preview';
-  } else if (previewSupportLevels['tech-preview'].length) {
-    supportLevel = 'tech-preview';
-  } else {
-    return null;
-  }
-  const featureList = previewSupportLevels[supportLevel].map((featureId: FeatureId) => (
-    <TextListItem key={featureId}>{getFeatureReviewText(featureId)}</TextListItem>
-  ));
-  return (
-    <>
-      <TextListItem>
-        {getPreviewSupportLevelTitle(supportLevel)}
-        <TextList>{featureList}</TextList>
-      </TextListItem>
-    </>
-  );
-};
-
-export const LimitedSupportedCluster = ({
-  clusterFeatureSupportLevels,
-  showVersionWarning,
-}: {
-  clusterFeatureSupportLevels: FeatureIdToSupportLevel;
-  showVersionWarning: boolean;
-}) => (
-  <TextContent>
-    {showVersionWarning && (
-      <Text>
-        <InfoCircleIcon size="sm" color="var(--pf-global--info-color--100)" />
-        &nbsp;The installed OpenShift version is not production-ready
-      </Text>
-    )}
-    {Object.keys(clusterFeatureSupportLevels).length > 0 && (
-      <>
-        <InfoCircleIcon size="sm" color="var(--pf-global--info-color--100)" />
-        &nbsp;Your cluster will be subject to support limitations because it includes:
-        <TextList>
-          {getPreviewFeatureList(clusterFeatureSupportLevels)}
-          {clusterFeatureSupportLevels['CLUSTER_MANAGED_NETWORKING_WITH_VMS'] === 'unsupported' && (
-            <TextListItem>
-              Cluster-managed networking with some or all discovered hosts as virtual machines
-            </TextListItem>
-          )}
-        </TextList>
-      </>
-    )}
-  </TextContent>
-);
-
-export const FullySupportedCluster = () => (
-  <>
-    <CheckCircleIcon color={okColor.value} />
-    &nbsp;Your installed cluster will be fully supported
-  </>
-);
-
-export const getFeatureSupportLevelTitle = (fullySupported: boolean): string => {
-  const supportLevel: string = fullySupported ? 'Full' : 'Limited';
-  return `Cluster support level: ${supportLevel}`;
-};
-
-type SupportLevelProps = { cluster: Cluster };
-export type SupportLevelMemo = {
-  limitedClusterFeatures: FeatureIdToSupportLevel;
-  hasSupportedVersion: boolean;
-  isFullySupported: boolean;
-};
-
-export const getSupportLevelInfo = (
-  cluster: Cluster,
-  featureSupportLevelData: NewFeatureSupportLevelData,
-  isSupportedOpenShiftVersion: (version?: string) => boolean,
-  t: TFunction,
-) => {
-  const limitedClusterFeatures = getLimitedFeatureSupportLevels(
-    cluster,
-    featureSupportLevelData,
-    t,
-  );
-  const hasSupportedVersion: boolean = isSupportedOpenShiftVersion(cluster.openshiftVersion);
-  return {
-    limitedClusterFeatures,
-    hasSupportedVersion,
-    isFullySupported: hasSupportedVersion && Object.keys(limitedClusterFeatures || {}).length === 0,
-  };
-};
-
-const SupportLevel = ({ cluster }: SupportLevelProps) => {
-  const { t } = useTranslation();
-  const featureSupportLevelData = useNewFeatureSupportLevel();
-  const { isSupportedOpenShiftVersion } = useOpenshiftVersions();
-
-  const { limitedClusterFeatures, hasSupportedVersion, isFullySupported } =
-    React.useMemo<SupportLevelMemo>(
-      () => getSupportLevelInfo(cluster, featureSupportLevelData, isSupportedOpenShiftVersion, t),
-      [cluster, featureSupportLevelData, t, isSupportedOpenShiftVersion],
-    );
-
-  if (!limitedClusterFeatures) {
-    return null;
-  }
-
-  return (
-    <DetailItem
-      title={getFeatureSupportLevelTitle(isFullySupported)}
-      value={
-        isFullySupported ? (
-          <FullySupportedCluster />
-        ) : (
-          <LimitedSupportedCluster
-            clusterFeatureSupportLevels={limitedClusterFeatures}
-            showVersionWarning={!hasSupportedVersion}
-          />
-        )
-      }
-      classNameValue={'pf-u-mb-md'}
-      testId="feature-support-levels"
-    />
-  );
-};
-
-const ClusterFeatureSupportLevelsDetailItem = ({ ...props }: SupportLevelProps) => (
-  <WithErrorBoundary title="Failed to load feature support levels review">
-    <SupportLevel {...props} />
-  </WithErrorBoundary>
-);
-export default ClusterFeatureSupportLevelsDetailItem;

package/lib/ocm/components/newFeatureSupportLevels/index.ts

@@ -1,2 +0,0 @@
-export { default as NewFeatureSupportLevelProvider } from './NewFeatureSupportLevelProvider';
-export { default as ClusterNewFeatureSupportLevelsDetailItem } from './ReviewClusterNewFeatureSupportLevels';

package/lib/ocm/components/newFeatureSupportLevels/newFeatureStateUtils.ts

@@ -1,174 +0,0 @@
-import {
-  ActiveFeatureConfiguration,
-  Cluster,
-  CpuArchitecture,
-  FeatureId,
-  isSNO,
-  OperatorsValues,
-  SupportLevel,
-  SupportedCpuArchitecture,
-} from '../../../common';
-import { architectureData } from '../clusterConfiguration/CpuArchitectureDropdown';
-
-const CNV_OPERATOR_LABEL = 'Openshift Virtualization';
-const LVMS_OPERATOR_LABEL = 'Logical Volume Manager Storage';
-const LVM_OPERATOR_LABEL = 'Logical Volume Manager';
-const ODF_OPERATOR_LABEL = 'OpenShift Data Foundation';
-
-export const clusterExistsReason = 'This option is not editable after the draft cluster is created';
-
-export const getCnvIncompatibleWithLvmReason = (
-  operatorValues: OperatorsValues,
-  lvmSupport: SupportLevel | undefined,
-) => {
-  const mustDisableCnv =
-    !operatorValues.useContainerNativeVirtualization &&
-    operatorValues.useOdfLogicalVolumeManager &&
-    lvmSupport !== 'supported';
-  // In versions with none or limited support for LVM (< 4.12), it's not possible to select CNV + LVM
-  return mustDisableCnv
-    ? `Currently, you can not install ${CNV_OPERATOR_LABEL} operator at the same time as ${LVM_OPERATOR_LABEL} operator.`
-    : undefined;
-};
-
-export const getLvmIncompatibleWithCnvReason = (
-  operatorValues: OperatorsValues,
-  lvmSupport: SupportLevel | undefined,
-) => {
-  const hasSelectedCnv = operatorValues.useContainerNativeVirtualization;
-  const hasSelectedLVMS = operatorValues.useOdfLogicalVolumeManager;
-  // In versions which support for LVMS (4.12+), LVMS needs to be installed together with CNV
-  if (hasSelectedCnv && hasSelectedLVMS) {
-    return `${LVMS_OPERATOR_LABEL} must be installed when ${CNV_OPERATOR_LABEL} operator is also installed`;
-  }
-  // In versions with none or limited support for LVM (< 4.12), it's not possible to select CNV + LVM
-  if (hasSelectedCnv && lvmSupport !== 'supported') {
-    return `Currently, you can not install ${LVM_OPERATOR_LABEL} operator at the same time as ${CNV_OPERATOR_LABEL} operator.`;
-  }
-  return undefined;
-};
-
-const getSNODisabledReason = (cluster: Cluster | undefined, isSupported: boolean) => {
-  if (cluster) {
-    return clusterExistsReason;
-  }
-  if (!isSupported) {
-    return 'Single-Node OpenShift is not supported in this OpenShift version';
-  }
-  return '';
-};
-
-const getArmDisabledReason = (cluster: Cluster | undefined) => {
-  if (cluster) {
-    return clusterExistsReason;
-  } else return 'arm64 is not supported in this OpenShift version';
-};
-
-const getOdfDisabledReason = (
-  cluster: Cluster | undefined,
-  activeFeatureConfiguration: ActiveFeatureConfiguration | undefined,
-  isSupported: boolean,
-) => {
-  if (!cluster) {
-    return undefined;
-  }
-
-  const isArm = activeFeatureConfiguration?.underlyingCpuArchitecture === CpuArchitecture.ARM;
-  if (isArm && isSNO(cluster)) {
-    return `${ODF_OPERATOR_LABEL} is not available when using Single Node OpenShift or ARM CPU architecture.`;
-  }
-  if (isArm) {
-    return `${ODF_OPERATOR_LABEL} is not available when ARM CPU architecture is selected.`;
-  }
-  if (isSNO(cluster)) {
-    return `${ODF_OPERATOR_LABEL} is not available when deploying a Single Node OpenShift.`;
-  }
-  if (!isSupported) {
-    return `The installer cannot currently enable ${ODF_OPERATOR_LABEL} with the selected OpenShift version, but it can be enabled later through the OpenShift Console once the installation is complete.`;
-  }
-  return undefined;
-};
-
-const getCnvDisabledReason = (
-  activeFeatureConfiguration: ActiveFeatureConfiguration,
-  isSupported: boolean,
-) => {
-  if (!activeFeatureConfiguration) {
-    return undefined;
-  }
-  if (!isSupported) {
-    const cpuArchitectureLabel =
-      architectureData[
-        activeFeatureConfiguration.underlyingCpuArchitecture as SupportedCpuArchitecture
-      ].label;
-    return `${CNV_OPERATOR_LABEL} is not available when ${
-      cpuArchitectureLabel
-        ? cpuArchitectureLabel
-        : activeFeatureConfiguration.underlyingCpuArchitecture
-    } CPU architecture is selected.`;
-  } else {
-    return undefined;
-  }
-};
-
-const getLvmDisabledReason = (
-  activeFeatureConfiguration: ActiveFeatureConfiguration,
-  isSupported: boolean,
-) => {
-  if (!activeFeatureConfiguration) {
-    return undefined;
-  }
-  const operatorLabel = isSupported ? LVMS_OPERATOR_LABEL : LVM_OPERATOR_LABEL;
-  if (!isSupported) {
-    return `${operatorLabel} is not supported in this OpenShift version.`;
-  }
-  return undefined;
-};
-
-const getNetworkTypeSelectionDisabledReason = (cluster: Cluster | undefined) => {
-  if (!cluster) {
-    return undefined;
-  }
-  if (isSNO(cluster)) {
-    return 'Network management selection is not supported for Single-Node OpenShift';
-  }
-  return undefined;
-};
-
-export const getNewFeatureDisabledReason = (
-  featureId: FeatureId,
-  cluster: Cluster | undefined,
-  activeFeatureConfiguration: ActiveFeatureConfiguration,
-  isSupported: boolean,
-): string | undefined => {
-  switch (featureId) {
-    case 'SNO': {
-      return getSNODisabledReason(cluster, isSupported);
-    }
-    case 'ARM64_ARCHITECTURE': {
-      return getArmDisabledReason(cluster);
-    }
-    case 'CNV': {
-      return getCnvDisabledReason(activeFeatureConfiguration, isSupported);
-    }
-    case 'LVM': {
-      return getLvmDisabledReason(activeFeatureConfiguration, isSupported);
-    }
-    case 'ODF': {
-      return getOdfDisabledReason(cluster, activeFeatureConfiguration, isSupported);
-    }
-    case 'NETWORK_TYPE_SELECTION': {
-      return getNetworkTypeSelectionDisabledReason(cluster);
-    }
-    case 'ARM64_ARCHITECTURE_WITH_CLUSTER_MANAGED_NETWORKING': {
-      return 'Network management selection is not supported for ARM architecture with this version of OpenShift.';
-    }
-    default: {
-      return undefined;
-    }
-  }
-};
-
-export const isFeatureSupportedAndAvailable = (supportLevel: SupportLevel | undefined): boolean => {
-  return supportLevel !== 'unsupported' && supportLevel !== 'unavailable';
-};

package/lib/ocm/reducers/clusters/clustersSlice.ts

@@ -1,64 +0,0 @@
-import {
-  createSlice,
-  createAsyncThunk,
-  PayloadAction,
-  ThunkDispatch,
-  AnyAction,
-  Dispatch,
-} from '@reduxjs/toolkit';
-import { Cluster, ResourceUIState } from '../../../common';
-import { ClustersAPI } from '../../services/apis';
-import { handleApiError, ocmClient } from '../../api';
-
-export const fetchClustersAsync = createAsyncThunk<Cluster[] | void>(
-  'clusters/fetchClustersAsync',
-  async (value, { rejectWithValue }) => {
-    try {
-      const { data } = await ClustersAPI.list();
-      const isOcm = !!ocmClient;
-      return data.filter((cluster) => (isOcm ? cluster.kind === 'Cluster' : true));
-    } catch (e) {
-      return handleApiError(e, () => rejectWithValue(value));
-    }
-  },
-);
-
-type ClustersStateSlice = {
-  data: Cluster[];
-  uiState: ResourceUIState;
-};
-
-export type ClustersDispatch = ThunkDispatch<ClustersStateSlice, undefined, AnyAction> & Dispatch;
-
-const initialState: ClustersStateSlice = { data: [], uiState: ResourceUIState.LOADING };
-
-export const clustersSlice = createSlice({
-  initialState,
-  name: 'clusters',
-  reducers: {
-    deleteCluster: (state, action: PayloadAction<Cluster['id']>) => ({
-      ...state,
-      data: state.data.filter((item: Cluster) => item.id !== action.payload),
-    }),
-  },
-  extraReducers: (builder) => {
-    const { LOADED, LOADING, RELOADING, POLLING_ERROR } = ResourceUIState;
-    builder
-      .addCase(fetchClustersAsync.pending, (state) => {
-        const uiState = state.uiState === LOADED ? RELOADING : LOADING;
-        return { ...state, uiState };
-      })
-      .addCase(fetchClustersAsync.fulfilled, (state, action) => ({
-        ...state,
-        data: [...(action.payload as Cluster[])],
-        uiState: LOADED,
-      }))
-      .addCase(fetchClustersAsync.rejected, (state) => ({
-        ...state,
-        uiState: POLLING_ERROR,
-      }));
-  },
-});
-
-export const { deleteCluster } = clustersSlice.actions;
-export default clustersSlice.reducer;

package/lib/ocm/reducers/clusters/currentClusterSlice.ts

@@ -1,157 +0,0 @@
-import findIndex from 'lodash-es/findIndex.js';
-import set from 'lodash-es/set.js';
-import { AxiosError } from 'axios';
-import {
-  AnyAction,
-  createAsyncThunk,
-  createSlice,
-  Dispatch,
-  PayloadAction,
-  ThunkDispatch,
-} from '@reduxjs/toolkit';
-import {
-  AssistedInstallerPermissionTypesListType,
-  Cluster,
-  Host,
-  ResourceUIState,
-} from '../../../common';
-import {
-  getApiErrorMessage,
-  getApiErrorCode,
-  handleApiError,
-  FETCH_ABORTED_ERROR_CODE,
-} from '../../api';
-import { ClustersService } from '../../services';
-
-export type FetchErrorType = {
-  code: string | number;
-  message: string;
-};
-
-type CurrentClusterStateSlice = {
-  data?: Cluster;
-  uiState: ResourceUIState;
-  isReloadScheduled: number;
-  permissions: AssistedInstallerPermissionTypesListType;
-  errorDetail?: FetchErrorType;
-};
-
-export type ClusterDispatch = ThunkDispatch<CurrentClusterStateSlice, undefined, AnyAction> &
-  Dispatch;
-
-export const fetchClusterAsync = createAsyncThunk<
-  Cluster | void,
-  string,
-  {
-    rejectValue: FetchErrorType;
-  }
->('currentCluster/fetchClusterAsync', async (clusterId, { rejectWithValue }) => {
-  try {
-    const cluster = await ClustersService.get(clusterId);
-    return cluster;
-  } catch (e) {
-    return handleApiError(e, () => {
-      return rejectWithValue({
-        code: getApiErrorCode(e as Error | AxiosError),
-        message: getApiErrorMessage(e),
-      });
-    });
-  }
-});
-
-const initialState: CurrentClusterStateSlice = {
-  data: undefined,
-  uiState: ResourceUIState.LOADING,
-  permissions: { isViewerMode: false },
-  errorDetail: undefined,
-  isReloadScheduled: 0,
-};
-
-export const currentClusterSlice = createSlice({
-  initialState,
-  name: 'currentCluster',
-  reducers: {
-    updateClusterBase: (state, action: PayloadAction<Cluster>) => {
-      // Should not overwrite the hosts once they are created
-      const originalHosts = state.data?.hosts || [];
-      return { ...state, data: { ...action.payload, hosts: originalHosts } };
-    },
-    updateCluster: (state, action: PayloadAction<Cluster>) => {
-      return { ...state, data: action.payload };
-    },
-    updateHost: (state, action: PayloadAction<Host>) => {
-      const hostIndex = findIndex(state.data?.hosts, (host) => host.id === action.payload.id);
-
-      if (hostIndex >= 0) {
-        set(state, `data.hosts[${hostIndex}]`, action.payload);
-      }
-      return state;
-    },
-    setServerUpdateError: (state) => {
-      return { ...state, uiState: ResourceUIState.UPDATE_ERROR };
-    },
-    cleanCluster: () => initialState,
-    forceReload: (state) => ({
-      ...state,
-      isReloadScheduled: state.isReloadScheduled + 1,
-    }),
-    cancelForceReload: (state) => ({
-      ...state,
-      isReloadScheduled: 0,
-    }),
-    updateClusterPermissions: (
-      state,
-      action: PayloadAction<AssistedInstallerPermissionTypesListType>,
-    ) => ({
-      ...state,
-      permissions: action.payload,
-    }),
-  },
-  extraReducers: (builder) => {
-    builder
-      .addCase(fetchClusterAsync.pending, (state) => {
-        const needsReload =
-          state.uiState === ResourceUIState.LOADED ||
-          (state.uiState === ResourceUIState.POLLING_ERROR && state.data);
-        return {
-          ...state,
-          uiState: needsReload ? ResourceUIState.RELOADING : ResourceUIState.LOADING,
-        };
-      })
-      .addCase(fetchClusterAsync.fulfilled, (state, action) => {
-        return {
-          ...state,
-          data: action.payload as Cluster,
-          uiState: ResourceUIState.LOADED,
-        };
-      })
-      .addCase(fetchClusterAsync.rejected, (state, action) => {
-        const error = action.payload as FetchErrorType;
-        if (error.code === FETCH_ABORTED_ERROR_CODE && !!state.data) {
-          // This failure is due to having aborted the request on purpose (to avoid conflicts with update operations).
-          // The error can be ignored, and the data will be refreshed on the next polling
-          return {
-            ...state,
-            uiState: ResourceUIState.LOADED,
-          };
-        }
-        return {
-          ...state,
-          uiState: ResourceUIState.POLLING_ERROR,
-          errorDetail: error,
-        };
-      });
-  },
-});
-
-export const {
-  updateCluster,
-  updateClusterBase,
-  updateHost,
-  setServerUpdateError,
-  cleanCluster,
-  forceReload,
-  cancelForceReload,
-  updateClusterPermissions,
-} = currentClusterSlice.actions;
-export default currentClusterSlice.reducer;

package/lib/ocm/reducers/clusters/index.ts

@@ -1,2 +0,0 @@
-export * from './clustersSlice';
-export * from './currentClusterSlice';

package/lib/ocm/selectors/clusters.tsx

@@ -1,108 +0,0 @@
-import React from 'react';
-import { createSelector } from '@reduxjs/toolkit';
-import { IRow, IRowData } from '@patternfly/react-table';
-import { Link } from 'react-router-dom';
-import { TFunction } from 'i18next';
-
-import {
-  Cluster,
-  DASH,
-  getDateTimeCell,
-  getEnabledHostCount,
-  getOpenshiftVersionText,
-  getTotalHostCount,
-  ClusterTableRows,
-  HostsCount,
-  HumanizedSortable,
-  ResourceUIState,
-} from '../../common';
-import ClusterStatus, { getClusterStatusText } from '../components/clusters/ClusterStatus';
-import { routeBasePath } from '../config';
-import { RootState } from '../store';
-
-const selectClusters = (state: RootState) => state.clusters.data;
-const clustersUIState = (state: RootState) => state.clusters.uiState;
-
-export const selectClustersUIState = createSelector(
-  [selectClusters, clustersUIState],
-  (clusters, uiState): ResourceUIState => {
-    const { LOADED, EMPTY } = ResourceUIState;
-    return !clusters.length && uiState === LOADED ? EMPTY : uiState;
-  },
-);
-
-export type ClusterRowDataProps = {
-  id: string;
-  name: string;
-  baseDnsDomain?: string;
-};
-
-const clusterToClusterTableRow = (cluster: Cluster, t: TFunction): IRow => {
-  const { id, name = '', baseDnsDomain, createdAt } = cluster;
-  const dateTimeCell = getDateTimeCell(createdAt);
-  const versionText = getOpenshiftVersionText({
-    openshiftVersion: cluster.openshiftVersion || '',
-    cpuArchitecture: cluster.cpuArchitecture,
-    withMultiText: true,
-  });
-  const props: ClusterRowDataProps = {
-    name,
-    id,
-    baseDnsDomain,
-  };
-
-  return {
-    cells: [
-      {
-        title: (
-          <Link key={name} to={`${routeBasePath}/clusters/${id}`} id={`cluster-link-${id}`}>
-            {name}
-          </Link>
-        ),
-        props: { 'data-testid': `cluster-name-${name}` },
-        sortableValue: name,
-      } as HumanizedSortable,
-      {
-        title: baseDnsDomain || DASH,
-        props: { 'data-testid': `cluster-base-domain-${name}` },
-        sortableValue: baseDnsDomain,
-      },
-      {
-        title: versionText,
-        props: { 'data-testid': `cluster-version-${name}` },
-        sortableValue: versionText,
-      },
-      {
-        title: <ClusterStatus status={cluster.status} />,
-        props: { 'data-testid': `cluster-status-${name}` },
-        sortableValue: getClusterStatusText(t, cluster.status),
-      } as HumanizedSortable,
-      {
-        title: <HostsCount cluster={cluster} />,
-        props: { 'data-testid': `cluster-hosts-count-${name}` },
-        sortableValue:
-          'enabledHostCount' in cluster ? getEnabledHostCount(cluster) : getTotalHostCount(cluster),
-      } as HumanizedSortable,
-      {
-        title: dateTimeCell.title,
-        props: { 'data-testid': `cluster-created-time-${name}` },
-        sortableValue: dateTimeCell.sortableValue,
-      } as HumanizedSortable,
-    ],
-    props,
-  };
-};
-
-export const getClusterTableStatusCell = (rowData: IRowData) =>
-  rowData?.cells?.[3] as HumanizedSortable;
-
-export const selectClusterTableRows = (t: TFunction) => {
-  return createSelector(
-    selectClusters,
-    (clusters): ClusterTableRows => clusters.map((c) => clusterToClusterTableRow(c, t)),
-  );
-};
-
-export const selectClusterNames = createSelector(selectClusters, (clusters) =>
-  clusters.map((c) => c.name),
-);