@openshift-assisted/ui-lib 2.42.0 → 2.42.2

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
+import { Cluster, SupportLevel } from '@openshift-assisted/types/assisted-installer-service';
 import { FeatureId } from '../../types';
 import {
   OPERATOR_NAME_AMD_GPU,
@@ -19,9 +19,6 @@ import {
   OPERATOR_NAME_PIPELINES,
   OPERATOR_NAME_SERVERLESS,
   OPERATOR_NAME_SERVICEMESH,
-  OPERATOR_NAME_NODE_HEALTHCHECK,
-  OPERATOR_NAME_SELF_NODE_REMEDIATION,
-  OPERATOR_NAME_FENCE_AGENTS_REMEDIATION,
   OPERATOR_NAME_NODE_MAINTENANCE,
   OPERATOR_NAME_KUBE_DESCHEDULER,
 } from '../../config/constants';
@@ -29,7 +26,6 @@ import { ExternalLink } from '../ui';
 import {
   AUTHORINO_OPERATOR_LINK,
   CNV_LINK,
-  FENCE_AGENTS_REMEDIATION_LINK,
   getKmmDocsLink,
   getKubeDeschedulerLink,
   getLsoLink,
@@ -40,7 +36,6 @@ import {
   getNvidiaGpuLink,
   getServiceMeshLink,
   MTV_LINK,
-  NODE_HEALTHCHECK_LINK,
   NODE_MAINTENANCE_LINK,
   ODF_LINK,
   ODF_REQUIREMENTS_LINK,
@@ -49,11 +44,31 @@ import {
   OSC_LINK,
   OSC_REQUIREMENTS_LINK,
   PIPELINES_OPERATOR_LINK,
-  SELF_NODE_REMEDIATION_LINK,
   SERVERLESS_OPERATOR_LINK,
 } from '../../config';
 import { getMajorMinorVersion } from '../../utils';
-import { useNewFeatureSupportLevel } from '../newFeatureSupportLevels';
+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 = (
@@ -68,280 +83,393 @@ export const isOCPVersionEqualsOrMore = (
   );
 };
 
+export const highlightMatch = (text: string, searchTerm?: string): React.ReactNode => {
+  if (!searchTerm) return text;
+  try {
+    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,
+    );
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.log('failed to highlight search text', err);
+    return text;
+  }
+};
+
+export const HighlightedText = ({ text, searchTerm }: { text: string; searchTerm?: string }) => (
+  <>{highlightMatch(text, searchTerm)}</>
+);
+
 export type OperatorSpec = {
+  operatorKey: string;
   title: string;
   featureId: FeatureId;
-  Description?: React.ComponentType<{ openshiftVersion?: string }>;
+  descriptionText?: string;
+  Description?: React.ComponentType<{ openshiftVersion?: string; searchTerm?: string }>;
   notStandalone?: boolean;
   Requirements?: React.ComponentType<{ cluster: Cluster }>;
+  supportLevel?: SupportLevel | undefined;
 };
 
-export const getOperatorSpecs = (useLVMS?: boolean): { [key: string]: OperatorSpec } => {
+export const getOperatorSpecs = (
+  getFeatureSupportLevel: GetFeatureSupportLevel,
+  useLVMS?: boolean,
+): { [category: string]: OperatorSpec[] } => {
   return {
-    [OPERATOR_NAME_MTV]: {
-      title: 'Migration Toolkit for Virtualization',
-      featureId: 'MTV',
-      Description: () => (
-        <>
-          This Toolkit (MTV) enables you to migrate virtual machines from VMware vSphere, Red Hat
-          Virtualization, or OpenStack to OpenShift Virtualization running on Red Hat OpenShift.{' '}
-          <ExternalLink href={MTV_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_AMD_GPU]: {
-      title: 'AMD GPU',
-      featureId: 'AMD_GPU',
-      Requirements: () => <>Requires at least one supported AMD GPU</>,
-      Description: () => (
-        <>
-          Automate the management of AMD software components needed to provision and monitor GPUs.
-        </>
-      ),
-    },
-    [OPERATOR_NAME_LSO]: {
-      title: 'Local Storage Operator',
-      featureId: 'LSO',
-      Description: ({ openshiftVersion }) => (
-        <>
-          Allows provisioning of persistent storage by using local volumes.{' '}
-          <ExternalLink href={getLsoLink(openshiftVersion)}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_AUTHORINO]: {
-      title: 'Authorino',
-      featureId: 'AUTHORINO',
-      Description: () => (
-        <>
-          Lightweight external authorization service for tailor-made Zero Trust API security.{' '}
-          <ExternalLink href={AUTHORINO_OPERATOR_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_CNV]: {
-      title: 'OpenShift Virtualization',
-      featureId: 'CNV',
-      Requirements: () => (
-        <>Enabled CPU virtualization support in BIOS (Intel-VT / AMD-V) on all nodes</>
-      ),
-      Description: () => (
-        <>
-          Run virtual machines alongside containers on one platform.{' '}
-          <ExternalLink href={CNV_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_FENCE_AGENTS_REMEDIATION]: {
-      title: 'Fence Agents Remediation',
-      featureId: 'FENCE_AGENTS_REMEDIATION',
-      Description: () => (
-        <>
-          Externally fences failed nodes using power controllers.{' '}
-          <ExternalLink href={FENCE_AGENTS_REMEDIATION_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_KMM]: {
-      title: 'Kernel Module Management',
-      featureId: 'KMM',
-      Description: ({ openshiftVersion }) => (
-        <>
-          Management of kernel modules.{' '}
-          <ExternalLink href={getKmmDocsLink(openshiftVersion)}>Learn more</ExternalLink>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_KUBE_DESCHEDULER]: {
-      title: 'Kube Descheduler',
-      featureId: 'KUBE_DESCHEDULER',
-      Description: ({ openshiftVersion }) => (
-        <>
-          Evicts pods to reschedule them onto more suitable nodes.{' '}
-          <ExternalLink href={getKubeDeschedulerLink(openshiftVersion)}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_MCE]: {
-      title: 'Multicluster engine',
-      featureId: 'MCE',
-      Description: ({ openshiftVersion }) => (
-        <>
-          Create, import, and manage multiple clusters from this cluster.{' '}
-          <ExternalLink href={getMceDocsLink(openshiftVersion)}>Learn more</ExternalLink>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_NMSTATE]: {
-      title: 'NMState',
-      featureId: 'NMSTATE',
-      Description: ({ openshiftVersion }) => (
-        <>
-          Provides users with functionality to configure various network interface types, DNS, and
-          routing on cluster nodes.{' '}
-          <ExternalLink href={getNmstateLink(openshiftVersion)}>Learn more</ExternalLink>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_NODE_FEATURE_DISCOVERY]: {
-      title: 'Node Feature Discovery',
-      featureId: 'NODE_FEATURE_DISCOVERY',
-      Description: ({ openshiftVersion }) => (
-        <>
-          Manage the detection of hardware features and configuration by labeling nodes with
-          hardware-specific information.{' '}
-          <ExternalLink href={getNodeFeatureDiscoveryLink(openshiftVersion)}>
-            Learn more
+    [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>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_NODE_HEALTHCHECK]: {
-      title: 'Node Healthcheck',
-      featureId: 'NODE_HEALTHCHECK',
-      Description: () => (
-        <>
-          Identify Unhealthy Nodes.{' '}
-          <ExternalLink href={NODE_HEALTHCHECK_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_NODE_MAINTENANCE]: {
-      title: 'Node Maintenance',
-      featureId: 'NODE_MAINTENANCE',
-      Description: () => (
-        <>
-          Place nodes in maintenance mode.{' '}
-          <ExternalLink href={NODE_MAINTENANCE_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_NVIDIA_GPU]: {
-      title: 'NVIDIA GPU',
-      featureId: 'NVIDIA_GPU',
-      Requirements: () => <>Requires at least one supported NVIDIA GPU</>,
-      Description: ({ openshiftVersion }) => (
-        <>
-          Automate the management of NVIDIA software components needed to provision and monitor
-          GPUs. <ExternalLink href={getNvidiaGpuLink(openshiftVersion)}>Learn more</ExternalLink>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_ODF]: {
-      title: 'OpenShift Data Foundation',
-      featureId: 'ODF',
-      Requirements: () => (
-        <ExternalLink href={ODF_REQUIREMENTS_LINK}>
-          Learn more about the requirements for OpenShift Data Foundation
-        </ExternalLink>
-      ),
-      Description: () => (
-        <>
-          Persistent software-defined storage for hybrid applications.{' '}
-          <ExternalLink href={ODF_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_OPENSHIFT_AI]: {
-      title: 'OpenShift AI',
-      featureId: 'OPENSHIFT_AI',
-      Requirements: () => (
-        <ExternalLink href={OPENSHIFT_AI_REQUIREMENTS_LINK}>Learn more</ExternalLink>
-      ),
-      Description: () => (
-        <>
-          Train, serve, monitor and manage AI/ML models and applications.{' '}
-          <ExternalLink href={OPENSHIFT_AI_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_OSC]: {
-      title: 'OpenShift sandboxed containers',
-      featureId: 'OSC',
-      Requirements: () => (
-        <ExternalLink href={OSC_REQUIREMENTS_LINK}>
-          Learn more about the requirements for OpenShift sandboxed containers
-        </ExternalLink>
-      ),
-      Description: () => (
-        <>
-          OpenShift sandboxed containers support for OpenShift Container Platform provides users
-          with built-in support for running Kata Containers as an additional optional runtime. It
-          provides an additional virtualization machine(VM) isolation layer for pods.{' '}
-          <ExternalLink href={OSC_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-    },
-    [OPERATOR_NAME_PIPELINES]: {
-      title: 'Pipelines',
-      featureId: 'PIPELINES',
-      Description: () => (
-        <>
-          Cloud-native continuous integration and delivery (CI/CD) solution for building pipelines
-          using Tekton. <ExternalLink href={PIPELINES_OPERATOR_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_SELF_NODE_REMEDIATION]: {
-      title: 'Self Node Remediation',
-      featureId: 'SELF_NODE_REMEDIATION',
-      Description: () => (
-        <>
-          Allows nodes to reboot themselves when they become unhealthy.{' '}
-          <ExternalLink href={SELF_NODE_REMEDIATION_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_SERVERLESS]: {
-      title: 'Serverless',
-      featureId: 'SERVERLESS',
-      Description: () => (
-        <>
-          Deploy workflow applications based on the CNCF Serverless Workflow specification.{' '}
-          <ExternalLink href={SERVERLESS_OPERATOR_LINK}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_SERVICEMESH]: {
-      title: 'Service Mesh',
-      featureId: 'SERVICEMESH',
-      Description: ({ openshiftVersion }) => (
-        <>
-          Platform that provides behavioral insight and operational control over a service mesh.{' '}
-          <ExternalLink href={getServiceMeshLink(openshiftVersion)}>Learn more</ExternalLink>
-        </>
-      ),
-      notStandalone: true,
-    },
-    [OPERATOR_NAME_LVM]: {
-      title: useLVMS ? 'Logical Volume Manager Storage' : 'Logical Volume Manager',
-      featureId: 'LVM',
-      Description: ({ openshiftVersion }) =>
-        useLVMS ? (
+        ),
+        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 }) => (
           <>
-            Storage virtualization that offers a more flexible approach for disk space management.{' '}
-            <ExternalLink href={getLvmsDocsLink(openshiftVersion)}>Learn more</ExternalLink>
+            <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 }) => (
           <>
-            Storage virtualization that offers a more flexible approach for disk space management.
+            <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: ({ searchTerm }) => (
+          <>
+            <HighlightedText text={DESCRIPTION_NODE_MAINTENANCE} searchTerm={searchTerm} />{' '}
+            <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';
-  return React.useMemo(() => getOperatorSpecs(useLVMS), [useLVMS]);
+
+  // 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',
 };