@openshift-assisted/ui-lib 2.42.0 → 2.42.2

package/lib/common/components/operators/test.tsx

@@ -0,0 +1,469 @@
+import React from 'react';
+import { Cluster, SupportLevel } from '@openshift-assisted/types/assisted-installer-service';
+import { FeatureId } from '../../types';
+import {
+  OPERATOR_NAME_AMD_GPU,
+  OPERATOR_NAME_AUTHORINO,
+  OPERATOR_NAME_CNV,
+  OPERATOR_NAME_KMM,
+  OPERATOR_NAME_LSO,
+  OPERATOR_NAME_LVM,
+  OPERATOR_NAME_MCE,
+  OPERATOR_NAME_MTV,
+  OPERATOR_NAME_NMSTATE,
+  OPERATOR_NAME_NODE_FEATURE_DISCOVERY,
+  OPERATOR_NAME_NVIDIA_GPU,
+  OPERATOR_NAME_ODF,
+  OPERATOR_NAME_OPENSHIFT_AI,
+  OPERATOR_NAME_OSC,
+  OPERATOR_NAME_PIPELINES,
+  OPERATOR_NAME_SERVERLESS,
+  OPERATOR_NAME_SERVICEMESH,
+  OPERATOR_NAME_NODE_MAINTENANCE,
+  OPERATOR_NAME_KUBE_DESCHEDULER,
+} from '../../config/constants';
+import { ExternalLink } from '../ui';
+import {
+  AUTHORINO_OPERATOR_LINK,
+  CNV_LINK,
+  getKmmDocsLink,
+  getKubeDeschedulerLink,
+  getLsoLink,
+  getLvmsDocsLink,
+  getMceDocsLink,
+  getNmstateLink,
+  getNodeFeatureDiscoveryLink,
+  getNvidiaGpuLink,
+  getServiceMeshLink,
+  MTV_LINK,
+  NODE_MAINTENANCE_LINK,
+  ODF_LINK,
+  ODF_REQUIREMENTS_LINK,
+  OPENSHIFT_AI_LINK,
+  OPENSHIFT_AI_REQUIREMENTS_LINK,
+  OSC_LINK,
+  OSC_REQUIREMENTS_LINK,
+  PIPELINES_OPERATOR_LINK,
+  SERVERLESS_OPERATOR_LINK,
+} from '../../config';
+import { getMajorMinorVersion } from '../../utils';
+import { GetFeatureSupportLevel, useNewFeatureSupportLevel } from '../newFeatureSupportLevels';
+import {
+  DESCRIPTION_AMD_GPU,
+  DESCRIPTION_AUTHORINO,
+  DESCRIPTION_LSO,
+  DESCRIPTION_MTV,
+  DESCRIPTION_CNV,
+  DESCRIPTION_KMM,
+  DESCRIPTION_KUBE_DESCHEDULER,
+  DESCRIPTION_MCE,
+  DESCRIPTION_NMSTATE,
+  DESCRIPTION_NODE_FEATURE_DISCOVERY,
+  DESCRIPTION_NODE_MAINTENANCE,
+  DESCRIPTION_NVIDIA_GPU,
+  DESCRIPTION_ODF,
+  DESCRIPTION_OPENSHIFT_AI,
+  DESCRIPTION_OSC,
+  DESCRIPTION_PIPELINES,
+  DESCRIPTION_SERVERLESS,
+  DESCRIPTION_SERVICEMESH,
+  DESCRIPTION_LVM,
+} from './operatorDescriptions';
+
+// TODO check if it's unused and it can be deleted in favor of "isMajorMinorVersionEqualOrGreater"
+export const isOCPVersionEqualsOrMore = (
+  openshiftVersion: string,
+  ocpVersionToCompare: string,
+): boolean => {
+  const [majorA, minorA] = getMajorMinorVersion(openshiftVersion).split('.');
+  const [majorB, minorB] = ocpVersionToCompare.split('.');
+  return (
+    Number(majorA) > Number(majorB) ||
+    (Number(majorA) === Number(majorB) && Number(minorA) >= Number(minorB))
+  );
+};
+
+export const highlightMatch = (text: string, searchTerm?: string): React.ReactNode => {
+  if (!searchTerm) return text;
+  const escapeSearchTerm = searchTerm.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const regex = new RegExp(`(${escapeSearchTerm})`, 'gi');
+
+  const parts = text.split(regex);
+
+  return parts.map((part, i) =>
+    part.toLowerCase() === searchTerm.toLowerCase() ? <mark key={i}>{part}</mark> : part,
+  );
+};
+
+export const HighlightedText = ({ text, searchTerm }: { text: string; searchTerm?: string }) => (
+  <>{highlightMatch(text, searchTerm)}</>
+);
+
+export type OperatorSpec = {
+  operatorKey: string;
+  title: string;
+  featureId: FeatureId;
+  descriptionText?: string;
+  Description?: React.ComponentType<{ openshiftVersion?: string; searchTerm?: string }>;
+  notStandalone?: boolean;
+  Requirements?: React.ComponentType<{ cluster: Cluster }>;
+  supportLevel?: SupportLevel | undefined;
+};
+
+export const getOperatorSpecs = (
+  getFeatureSupportLevel: GetFeatureSupportLevel,
+  useLVMS?: boolean,
+): { [category: string]: OperatorSpec[] } => {
+  return {
+    [categories[Category.STORAGE]]: [
+      {
+        operatorKey: OPERATOR_NAME_LSO,
+        title: 'Local Storage Operator',
+        featureId: 'LSO',
+        descriptionText: DESCRIPTION_LSO,
+        Description: ({ openshiftVersion, searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_LSO} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={getLsoLink(openshiftVersion)}>Learn more</ExternalLink>
+          </>
+        ),
+        notStandalone: true,
+        supportLevel: getFeatureSupportLevel('LSO'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_LVM,
+        title: useLVMS ? 'Logical Volume Manager Storage' : 'Logical Volume Manager',
+        featureId: 'LVM',
+        descriptionText: DESCRIPTION_LVM,
+        Description: ({ openshiftVersion, searchTerm }) =>
+          useLVMS ? (
+            <>
+              <HighlightedText text={DESCRIPTION_LVM} searchTerm={searchTerm} />{' '}
+              <ExternalLink href={getLvmsDocsLink(openshiftVersion)}>Learn more</ExternalLink>
+            </>
+          ) : (
+            <>{DESCRIPTION_LVM}</>
+          ),
+        supportLevel: getFeatureSupportLevel('LVM'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_ODF,
+        title: 'OpenShift Data Foundation',
+        featureId: 'ODF',
+        descriptionText: DESCRIPTION_ODF,
+        Requirements: () => (
+          <ExternalLink href={ODF_REQUIREMENTS_LINK}>
+            Learn more about the requirements for OpenShift Data Foundation
+          </ExternalLink>
+        ),
+        Description: ({ searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_ODF} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={ODF_LINK}>Learn more</ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('ODF'),
+      },
+    ],
+    [categories[Category.VIRT]]: [
+      {
+        operatorKey: OPERATOR_NAME_CNV,
+        title: 'OpenShift Virtualization',
+        featureId: 'CNV',
+        descriptionText: DESCRIPTION_CNV,
+        Requirements: () => (
+          <>Enabled CPU virtualization support in BIOS (Intel-VT / AMD-V) on all nodes</>
+        ),
+        Description: ({ searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_CNV} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={CNV_LINK}>Learn more</ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('CNV'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_MTV,
+        title: 'Migration Toolkit for Virtualization',
+        featureId: 'MTV',
+        descriptionText: DESCRIPTION_MTV,
+        Description: ({ searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_MTV} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={MTV_LINK}>Learn more</ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('MTV'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_OSC,
+        title: 'OpenShift sandboxed containers',
+        featureId: 'OSC',
+        descriptionText: DESCRIPTION_OSC,
+        Requirements: () => (
+          <ExternalLink href={OSC_REQUIREMENTS_LINK}>
+            Learn more about the requirements for OpenShift sandboxed containers
+          </ExternalLink>
+        ),
+        Description: () => (
+          <>
+            {DESCRIPTION_OSC} <ExternalLink href={OSC_LINK}>Learn more</ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('OSC'),
+      },
+    ],
+    [categories[Category.AI]]: [
+      {
+        operatorKey: OPERATOR_NAME_OPENSHIFT_AI,
+        title: 'OpenShift AI',
+        featureId: 'OPENSHIFT_AI',
+        descriptionText: DESCRIPTION_OPENSHIFT_AI,
+        Requirements: () => (
+          <ExternalLink href={OPENSHIFT_AI_REQUIREMENTS_LINK}>Learn more</ExternalLink>
+        ),
+        Description: ({ searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_OPENSHIFT_AI} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={OPENSHIFT_AI_LINK}>Learn more</ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('OPENSHIFT_AI'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_AMD_GPU,
+        title: 'AMD GPU',
+        featureId: 'AMD_GPU',
+        descriptionText: DESCRIPTION_AMD_GPU,
+        Requirements: () => <>Requires at least one supported AMD GPU</>,
+        Description: ({ searchTerm }) => (
+          <>
+            {' '}
+            <HighlightedText text={DESCRIPTION_AMD_GPU} searchTerm={searchTerm} />{' '}
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('AMD_GPU'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_NVIDIA_GPU,
+        title: 'NVIDIA GPU',
+        featureId: 'NVIDIA_GPU',
+        descriptionText: DESCRIPTION_NVIDIA_GPU,
+        Requirements: () => <>Requires at least one supported NVIDIA GPU</>,
+        Description: ({ openshiftVersion, searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_NVIDIA_GPU} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={getNvidiaGpuLink(openshiftVersion)}>Learn more</ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('NVIDIA_GPU'),
+      },
+    ],
+    [categories[Category.NETWORK]]: [
+      {
+        operatorKey: OPERATOR_NAME_NMSTATE,
+        title: 'NMState',
+        featureId: 'NMSTATE',
+        descriptionText: DESCRIPTION_NMSTATE,
+        Description: ({ openshiftVersion, searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_NMSTATE} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={getNmstateLink(openshiftVersion)}>Learn more</ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('NMSTATE'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_SERVICEMESH,
+        title: 'Service Mesh',
+        featureId: 'SERVICEMESH',
+        descriptionText: DESCRIPTION_SERVICEMESH,
+        Description: ({ openshiftVersion, searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_SERVICEMESH} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={getServiceMeshLink(openshiftVersion)}>Learn more</ExternalLink>
+          </>
+        ),
+        notStandalone: true,
+        supportLevel: getFeatureSupportLevel('SERVICEMESH'),
+      },
+    ],
+    [categories[Category.SECURITY]]: [
+      {
+        operatorKey: OPERATOR_NAME_AUTHORINO,
+        title: 'Authorino',
+        featureId: 'AUTHORINO',
+        descriptionText: DESCRIPTION_AUTHORINO,
+        Description: ({ searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_AUTHORINO} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={AUTHORINO_OPERATOR_LINK}>Learn more</ExternalLink>
+          </>
+        ),
+        notStandalone: true,
+        supportLevel: getFeatureSupportLevel('AUTHORINO'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_KMM,
+        title: 'Kernel Module Management',
+        featureId: 'KMM',
+        descriptionText: DESCRIPTION_KMM,
+        Description: ({ openshiftVersion, searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_KMM} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={getKmmDocsLink(openshiftVersion)}>Learn more</ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('KMM'),
+      },
+    ],
+    [categories[Category.CI_CD]]: [
+      {
+        operatorKey: OPERATOR_NAME_PIPELINES,
+        title: 'Pipelines',
+        featureId: 'PIPELINES',
+        descriptionText: DESCRIPTION_PIPELINES,
+        Description: ({ searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_PIPELINES} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={PIPELINES_OPERATOR_LINK}>Learn more</ExternalLink>
+          </>
+        ),
+        notStandalone: true,
+        supportLevel: getFeatureSupportLevel('PIPELINES'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_SERVERLESS,
+        title: 'Serverless',
+        featureId: 'SERVERLESS',
+        descriptionText: DESCRIPTION_SERVERLESS,
+        Description: ({ searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_SERVERLESS} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={SERVERLESS_OPERATOR_LINK}>Learn more</ExternalLink>
+          </>
+        ),
+        notStandalone: true,
+        supportLevel: getFeatureSupportLevel('SERVERLESS'),
+      },
+    ],
+    [categories[Category.PLATFORM]]: [
+      {
+        operatorKey: OPERATOR_NAME_MCE,
+        title: 'Multicluster engine',
+        featureId: 'MCE',
+        descriptionText: DESCRIPTION_MCE,
+        Description: ({ openshiftVersion, searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_MCE} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={getMceDocsLink(openshiftVersion)}>Learn more</ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('MCE'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_NODE_MAINTENANCE,
+        title: 'Node Maintenance',
+        featureId: 'NODE_MAINTENANCE',
+        descriptionText: DESCRIPTION_NODE_MAINTENANCE,
+        Description: () => (
+          <>
+            {DESCRIPTION_NODE_MAINTENANCE}{' '}
+            <ExternalLink href={NODE_MAINTENANCE_LINK}>Learn more</ExternalLink>
+          </>
+        ),
+        notStandalone: true,
+        supportLevel: getFeatureSupportLevel('NODE_MAINTENANCE'),
+      },
+    ],
+    [categories[Category.SCHEDULING]]: [
+      {
+        operatorKey: OPERATOR_NAME_NODE_FEATURE_DISCOVERY,
+        title: 'Node Feature Discovery',
+        featureId: 'NODE_FEATURE_DISCOVERY',
+        descriptionText: DESCRIPTION_NODE_FEATURE_DISCOVERY,
+        Description: ({ openshiftVersion }) => (
+          <>
+            {DESCRIPTION_NODE_FEATURE_DISCOVERY}{' '}
+            <ExternalLink href={getNodeFeatureDiscoveryLink(openshiftVersion)}>
+              Learn more
+            </ExternalLink>
+          </>
+        ),
+        supportLevel: getFeatureSupportLevel('NODE_FEATURE_DISCOVERY'),
+      },
+      {
+        operatorKey: OPERATOR_NAME_KUBE_DESCHEDULER,
+        title: 'Kube Descheduler',
+        featureId: 'KUBE_DESCHEDULER',
+        descriptionText: DESCRIPTION_KUBE_DESCHEDULER,
+        Description: ({ openshiftVersion, searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_KUBE_DESCHEDULER} searchTerm={searchTerm} />{' '}
+            <ExternalLink href={getKubeDeschedulerLink(openshiftVersion)}>Learn more</ExternalLink>
+          </>
+        ),
+        notStandalone: true,
+        supportLevel: getFeatureSupportLevel('KUBE_DESCHEDULER'),
+      },
+    ],
+  };
+};
+
+export const useOperatorSpecs = () => {
+  const { getFeatureSupportLevel } = useNewFeatureSupportLevel();
+  const useLVMS = getFeatureSupportLevel('LVM') === 'supported';
+
+  // Grouped by category
+  const byCategory = React.useMemo(
+    () => getOperatorSpecs(getFeatureSupportLevel, useLVMS),
+    [getFeatureSupportLevel, useLVMS],
+  );
+
+  // Flat map operatorKey -> spec
+  const byKey: Record<string, OperatorSpec> = React.useMemo(() => {
+    return Object.values(byCategory).reduce((acc, specs) => {
+      specs.forEach((spec) => {
+        acc[spec.operatorKey] = spec;
+      });
+      return acc;
+    }, {} as Record<string, OperatorSpec>);
+  }, [byCategory]);
+
+  return { byCategory, byKey };
+};
+
+export const getOperatorTitleByFeatureId = (featureId: FeatureId): string | undefined => {
+  const allSpecs = getOperatorSpecs(() => undefined);
+
+  for (const categorySpecs of Object.values(allSpecs)) {
+    const spec = categorySpecs.find((s) => s.featureId === featureId);
+    if (spec) {
+      return spec.title;
+    }
+  }
+
+  return undefined;
+};
+
+enum Category {
+  STORAGE,
+  VIRT,
+  AI,
+  NETWORK,
+  CI_CD,
+  PLATFORM,
+  SECURITY,
+  SCHEDULING,
+}
+
+export const categories: { [key in Category]: string } = {
+  [Category.STORAGE]: 'Storage',
+  [Category.VIRT]: 'Virtualization',
+  [Category.AI]: 'AI',
+  [Category.NETWORK]: 'Network',
+  [Category.SECURITY]: 'Security & Access Control',
+  [Category.CI_CD]: 'CI/CD & Dev Productivity',
+  [Category.PLATFORM]: 'Platform Operations & Lifecycle',
+  [Category.SCHEDULING]: 'Scheduling',
+};

package/lib/ocm/components/clusterConfiguration/ControlPlaneNodesDropdown.tsx

@@ -9,18 +9,19 @@ import {
   DropdownList,
 } from '@patternfly/react-core';
 import { useField } from 'formik';
-import { getFieldId, PopoverIcon } from '../../../common';
+import { getFieldId, PopoverIcon, PreviewBadgePosition, TechnologyPreview } from '../../../common';
 import {
   NewFeatureSupportLevelMap,
   useNewFeatureSupportLevel,
 } from '../../../common/components/newFeatureSupportLevels';
+import { isFeatureSupportedAndAvailable } from '../featureSupportLevels/featureStateUtils';
 import OcmTNADisclaimer from './OcmTNADisclaimer';
 import toNumber from 'lodash-es/toNumber';
 import OcmSNODisclaimer from './OcmSNODisclaimer';
 
 const INPUT_NAME = 'controlPlaneCount';
 const fieldId = getFieldId(INPUT_NAME, 'input');
-const DEFAULT_VALUE = 3;
+export const DEFAULT_VALUE_CPN = 3;
 
 export const ControlPlaneNodesLabel = () => {
   return (
@@ -42,13 +43,14 @@ export const ControlPlaneNodesLabel = () => {
 interface ControlPlaneNodesOption {
   value: number;
   label: string;
+  badge?: React.ReactNode;
 }
 
 interface ControlPlaneNodesDropdownProps {
   featureSupportLevelData?: NewFeatureSupportLevelMap | null;
 }
 
-const isDropdownItemEnabled = (
+export const isCPNDropdownItemEnabled = (
   controlPlaneNodeCount: number,
   isNonStandardControlPlaneEnabled: boolean,
   isTnaEnabled: boolean,
@@ -83,29 +85,37 @@ const ControlPlaneNodesDropdown: React.FC<ControlPlaneNodesDropdownProps> = ({
   );
 
   const disabledReason =
-    'This option is not available with the current configurations. Make sure that OpenShift version is 4.18 or newer, CPU architecture is x86_64 and no external platform integration is selected.';
+    'This option is not available with the current configurations. Make sure that OpenShift version is 4.19 or newer and no external platform integration is selected.';
 
   const isNonStandardControlPlaneEnabled = newFeatureSupportLevelContext.isFeatureSupported(
     'NON_STANDARD_HA_CONTROL_PLANE',
     featureSupportLevelData ?? undefined,
   );
 
+  const tnaSupport = newFeatureSupportLevelContext.getFeatureSupportLevel(
+    'TNA',
+    featureSupportLevelData ?? undefined,
+  );
+  const isTnaEnabled = isFeatureSupportedAndAvailable(tnaSupport || 'unsupported');
+
   const options: ControlPlaneNodesOption[] = [
     { value: 1, label: '1 (Single Node OpenShift)' },
-    { value: 2, label: '2 (Two-Nodes Arbiter)' },
+    {
+      value: 2,
+      label: '2 (Two-Nodes Arbiter)',
+      badge:
+        tnaSupport === 'tech-preview' ? (
+          <TechnologyPreview position={PreviewBadgePosition.default} />
+        ) : undefined,
+    },
     { value: 3, label: '3 (highly available cluster)' },
     { value: 4, label: '4 (highly available cluster+)' },
     { value: 5, label: '5 (highly available cluster++)' },
   ];
 
-  const isTnaEnabled = newFeatureSupportLevelContext.isFeatureSupported(
-    'TNA',
-    featureSupportLevelData ?? undefined,
-  );
-
   React.useEffect(() => {
     if (!field.value) {
-      setValue(DEFAULT_VALUE);
+      setValue(DEFAULT_VALUE_CPN);
     }
   }, [field.value, setValue]);
 
@@ -115,8 +125,8 @@ const ControlPlaneNodesDropdown: React.FC<ControlPlaneNodesDropdownProps> = ({
     setOpen(false);
   };
 
-  const dropdownItems = options.map(({ value, label }) => {
-    const isItemEnabled = isDropdownItemEnabled(
+  const dropdownItems = options.map(({ value, label, badge }) => {
+    const isItemEnabled = isCPNDropdownItemEnabled(
       value,
       isNonStandardControlPlaneEnabled,
       isTnaEnabled,
@@ -124,7 +134,9 @@ const ControlPlaneNodesDropdown: React.FC<ControlPlaneNodesDropdownProps> = ({
     return (
       <DropdownItem key={value} id={value.toString()} isAriaDisabled={!isItemEnabled}>
         <Tooltip hidden={isItemEnabled} content={disabledReason} position="top">
-          <div>{label}</div>
+          <div>
+            {label} {badge}
+          </div>
         </Tooltip>
       </DropdownItem>
     );

package/lib/ocm/components/clusterConfiguration/OcmClusterDetailsFormFields.tsx

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import * as React from 'react';
 import { Form } from '@patternfly/react-core';
 import { useFormikContext } from 'formik';
@@ -32,7 +33,11 @@ import { ExternalPlatformLabels } from './platformIntegration/constants';
 import { ManagedDomain, PlatformType } from '@openshift-assisted/types/assisted-installer-service';
 import { useClusterWizardContext } from '../clusterWizard/ClusterWizardContext';
 import { useFeature } from '../../hooks/use-feature';
-import ControlPlaneNodesDropdown, { ControlPlaneNodesLabel } from './ControlPlaneNodesDropdown';
+import ControlPlaneNodesDropdown, {
+  ControlPlaneNodesLabel,
+  DEFAULT_VALUE_CPN,
+  isCPNDropdownItemEnabled,
+} from './ControlPlaneNodesDropdown';
 
 export type OcmClusterDetailsFormFieldsProps = {
   forceOpenshiftVersion?: string;
@@ -115,6 +120,33 @@ export const OcmClusterDetailsFormFields = ({
     );
   }, [setFieldValue, featureSupportLevelContext, featureSupportLevelData]);
 
+  React.useEffect(() => {
+    const currentCount = values.controlPlaneCount;
+    const isNonStandardControlPlaneEnabled = featureSupportLevelContext.isFeatureSupported(
+      'NON_STANDARD_HA_CONTROL_PLANE',
+      featureSupportLevelData ?? undefined,
+    );
+    const isTnaEnabled = featureSupportLevelContext.isFeatureSupported(
+      'TNA',
+      featureSupportLevelData ?? undefined,
+    );
+
+    const isItemEnabled = isCPNDropdownItemEnabled(
+      currentCount,
+      isNonStandardControlPlaneEnabled,
+      isTnaEnabled,
+    );
+
+    if (!isItemEnabled) {
+      setFieldValue('controlPlaneCount', DEFAULT_VALUE_CPN, false);
+    }
+  }, [
+    values.openshiftVersion,
+    featureSupportLevelData,
+    featureSupportLevelContext,
+    values.controlPlaneCount,
+    setFieldValue,
+  ]);
   return (
     <Form id="wizard-cluster-details__form">
       <OcmRichInputField

package/lib/ocm/components/clusterConfiguration/OcmOperatorProgressItem.tsx

@@ -80,7 +80,7 @@ type OperatorsPopoverProps = OperatorListProps & {
 
 const OperatorsPopover = ({ operators, children }: OperatorsPopoverProps) => {
   const { t } = useTranslation();
-  const opSpecs = useOperatorSpecs();
+  const { byKey: opSpecs } = useOperatorSpecs();
 
   return (
     <Popover

package/lib/ocm/components/clusterConfiguration/manifestsConfiguration/components/FolderDropdown.tsx

@@ -56,6 +56,7 @@ export const FolderDropdown = ({ name }: FolderDropdownProps) => {
       onClick={() => setOpen(!isOpen)}
       isExpanded={isOpen}
       className="pf-v5-u-w-100"
+      id={fieldId}
     >
       {value || 'manifests'}
     </MenuToggle>

package/lib/ocm/components/clusterConfiguration/operators/OperatorCheckbox.tsx

@@ -26,6 +26,7 @@ import { getFieldId, OperatorsValues, PopoverIcon } from '../../../../common';
 import { useNewFeatureSupportLevel } from '../../../../common/components/newFeatureSupportLevels';
 import { getNewOperators } from './utils';
 import {
+  highlightMatch,
   OperatorSpec,
   useOperatorSpecs,
 } from '../../../../common/components/operators/operatorSpecs';
@@ -118,15 +119,17 @@ const OperatorCheckbox = ({
   Requirements,
   openshiftVersion,
   preflightRequirements,
+  searchTerm,
 }: {
   bundles: Bundle[];
   cluster: Cluster;
   operatorId: string;
   openshiftVersion?: string;
   preflightRequirements: PreflightHardwareRequirements | undefined;
+  searchTerm?: string;
 } & OperatorSpec) => {
   const { getFeatureSupportLevel, getFeatureDisabledReason } = useNewFeatureSupportLevel();
-  const opSpecs = useOperatorSpecs();
+  const { byKey: opSpecs } = useOperatorSpecs();
 
   const { isViewerMode } = useSelector(selectCurrentClusterPermissionsState);
   const { values, setFieldValue } = useFormikContext<OperatorsValues>();
@@ -166,7 +169,7 @@ const OperatorCheckbox = ({
         label={
           <>
             <Tooltip hidden={!disabledReason} content={disabledReason}>
-              <span>{title} </span>
+              <span>{highlightMatch(title, searchTerm)} </span>
             </Tooltip>
             <OperatorRequirements
               operatorId={operatorId}
@@ -196,7 +199,7 @@ const OperatorCheckbox = ({
           !!Description && (
             <HelperText>
               <HelperTextItem variant="indeterminate">
-                <Description openshiftVersion={openshiftVersion} />
+                <Description openshiftVersion={openshiftVersion} searchTerm={searchTerm} />
               </HelperTextItem>
             </HelperText>
           )