@openshift-assisted/ui-lib 2.54.1 → 2.55.0

package/lib/common/components/clusterWizard/networkingSteps/StackTypeControlGroup.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ButtonVariant, FormGroup, Split, SplitItem, Tooltip } from '@patternfly/react-core';
+import { ButtonVariant, FormGroup, Radio, Split, SplitItem, Tooltip } from '@patternfly/react-core';
 import { useFormikContext } from 'formik';
 import { Address4, Address6 } from 'ip-address';
 
@@ -9,10 +9,9 @@ import {
   NETWORK_TYPE_OVN,
   NETWORK_TYPE_SDN,
 } from '../../../types';
-import { getFieldId } from '../../ui';
+import { ConfirmationModal, getFieldId, PopoverIcon } from '../../ui';
 import { DUAL_STACK, NO_SUBNET_SET, SINGLE_STACK } from '../../../config';
 import { RadioField } from '../../ui/formik';
-import { ConfirmationModal, PopoverIcon } from '../../ui';
 import { useTranslation } from '../../../hooks/use-translation-wrapper';
 import { reorderNetworksByCurrentPrimary } from './reorderNetworks';
 import {
@@ -72,36 +71,32 @@ export const StackTypeControlGroup = ({
 
   const IPv6Subnets = hostSubnets.filter((subnet) => Address6.isValid(subnet.subnet));
   const cidrIPv6 = IPv6Subnets.length >= 1 ? IPv6Subnets[0].subnet : NO_SUBNET_SET;
+  const isSingleStackSelected = values.stackType !== DUAL_STACK;
+
   const shouldSetSingleStack =
     !isViewerMode && !isDualStackSelectable && values.stackType === DUAL_STACK;
 
   const setSingleStack = React.useCallback(() => {
     setFieldValue('stackType', SINGLE_STACK);
 
-    // Determine whether the first machine network is IPv4
     const firstNetwork = values.machineNetworks?.[0];
     const isFirstIPv4 = Boolean(firstNetwork?.cidr && Address4.isValid(firstNetwork.cidr));
 
     if (values.machineNetworks && values.machineNetworks?.length >= 2) {
-      // For single-stack IPv4, prefer IPv4 machine network
       if (isFirstIPv4) {
-        // Keep the first network if it's IPv4
         setFieldValue('machineNetworks', [firstNetwork]);
       } else {
-        // If first is IPv6, look for IPv4 network or set empty for auto-selection
         const ipv4Network = values.machineNetworks.find(
           (network) => network.cidr && Address4.isValid(network.cidr),
         );
         if (ipv4Network) {
           setFieldValue('machineNetworks', [ipv4Network]);
         } else {
-          // No IPv4 network found, set empty for auto-selection
           setFieldValue('machineNetworks', []);
         }
       }
     }
 
-    // Set cluster/service to IPv4 defaults when switching to single-stack
     if (values.clusterNetworks && values.clusterNetworks.length >= 1) {
       const defaultCluster =
         defaultNetworkValues.clusterNetworksIpv4 && defaultNetworkValues.clusterNetworksIpv4[0];
@@ -110,12 +105,12 @@ export const StackTypeControlGroup = ({
         ? {
             cidr: defaultCluster.cidr,
             hostPrefix: defaultCluster.hostPrefix,
-            clusterId: firstCluster.clusterId, // ← Preserve clusterId from original network
+            clusterId: firstCluster.clusterId,
           }
         : {
             cidr: '',
             hostPrefix: '',
-            clusterId: clusterId, // ← Use current clusterId
+            clusterId: clusterId,
           };
       setFieldValue('clusterNetworks', [ipv4Cluster]);
     }
@@ -126,22 +121,20 @@ export const StackTypeControlGroup = ({
       const ipv4Service = defaultService
         ? {
             cidr: defaultService.cidr,
-            clusterId: firstService.clusterId, // ← Preserve clusterId from original network
+            clusterId: firstService.clusterId,
           }
         : {
             cidr: '',
-            clusterId: clusterId, // ← Use current clusterId
+            clusterId: clusterId,
           };
       setFieldValue('serviceNetworks', [ipv4Service]);
     }
 
-    // Keep only IPv4 VIPs when switching to single-stack (unless DHCP allocation is used)
     if (!values.vipDhcpAllocation) {
       const pruneVips = (
         vips?: { ip?: string; clusterId?: Cluster['id'] }[],
       ): { ip: string; clusterId: Cluster['id'] }[] => {
         if (!vips || vips.length === 0) return [];
-        // Choose which index to keep based on whether the first network is IPv4
         const keepIndex = isFirstIPv4 ? 0 : 1;
         const chosen = vips[keepIndex];
         return chosen && chosen.ip
@@ -177,12 +170,10 @@ export const StackTypeControlGroup = ({
     }
 
     if (values.machineNetworks && values.machineNetworks?.length < 2) {
-      // Ensure IPv4 is primary when switching to dual-stack
       const firstNetwork = values.machineNetworks[0];
       const isFirstIPv6 = firstNetwork?.cidr && Address6.isValid(firstNetwork.cidr);
 
       if (isFirstIPv6) {
-        // If first network is IPv6, make IPv4 primary and IPv6 secondary
         const IPv4Subnets = hostSubnets.filter((subnet) => Address4.isValid(subnet.subnet));
         const cidrIPv4 = IPv4Subnets.length >= 1 ? IPv4Subnets[0].subnet : NO_SUBNET_SET;
         setFieldValue(
@@ -194,7 +185,6 @@ export const StackTypeControlGroup = ({
           false,
         );
       } else {
-        // If first network is IPv4, add IPv6 as secondary
         setFieldValue(
           'machineNetworks',
           [...values.machineNetworks, { cidr: cidrIPv6, clusterId: clusterId }],
@@ -225,7 +215,6 @@ export const StackTypeControlGroup = ({
       };
       setFieldValue('serviceNetworks', [...values.serviceNetworks, secondServiceNetwork], false);
     }
-    // Initialize VIPs for dual-stack
     if (values.apiVips && values.apiVips.length < 2) {
       setFieldValue(
         'apiVips',
@@ -244,8 +233,9 @@ export const StackTypeControlGroup = ({
       );
     }
   };
-  // Ensure cluster/service networks ordering matches the new primary family
+
   const primaryCidr = values.machineNetworks?.[0]?.cidr;
+
   React.useEffect(() => {
     if (isViewerMode) {
       return;
@@ -261,10 +251,11 @@ export const StackTypeControlGroup = ({
     values.serviceNetworks,
   ]);
 
-  const setStackType = (e: React.ChangeEvent<HTMLInputElement>) => {
-    if (e.target.value === DUAL_STACK) {
-      setDualStack();
-    } else if (
+  const handleSingleStackRadioClick = () => {
+    if (isSingleStackSelected) {
+      return;
+    }
+    if (
       hasDualStackConfigurationChanged(
         defaultNetworkValues.clusterNetworksDualstack || [],
         defaultNetworkValues.serviceNetworksDualstack || [],
@@ -284,32 +275,34 @@ export const StackTypeControlGroup = ({
     }
   }, [shouldSetSingleStack, setSingleStack]);
 
+  const singleStackPopoverContent = allowSingleStackIPv6
+    ? t('ai:Select a single address family (IPv4 or IPv6) for your machine network.')
+    : t('ai:Select this when your hosts are using only IPv4.');
+
+  const singleStackRadioId = getFieldId('stackType', 'radio', SINGLE_STACK);
+
   return (
     <>
       <FormGroup
-        label="Networking stack type"
+        label={t('ai:Networking stack type')}
         fieldId={getFieldId('stackType', 'radio')}
-        onChange={setStackType}
         isInline
       >
         <Split>
           <SplitItem>
-            <RadioField
-              name={'stackType'}
+            <Radio
+              id={singleStackRadioId}
+              name="stackType"
               value={SINGLE_STACK}
-              isDisabled={!isDualStackSelectable || isViewerMode}
               label={`${singleStackLabel}\u00A0`}
+              isChecked={isSingleStackSelected}
+              isDisabled={!isDualStackSelectable || isViewerMode}
+              onChange={() => handleSingleStackRadioClick()}
+              data-testid="form-radio-stackType-singleStack-field"
             />
           </SplitItem>
           <SplitItem>
-            <PopoverIcon
-              bodyContent={
-                allowSingleStackIPv6
-                  ? t('ai:Select a single address family (IPv4 or IPv6) for your machine network.')
-                  : t('ai:Select this when your hosts are using only IPv4.')
-              }
-              buttonStyle={{ top: '-4px' }}
-            />
+            <PopoverIcon bodyContent={singleStackPopoverContent} buttonStyle={{ top: '-4px' }} />
           </SplitItem>
         </Split>
         <Split>
@@ -325,6 +318,8 @@ export const StackTypeControlGroup = ({
                 value={DUAL_STACK}
                 isDisabled={!isDualStackSelectable || isViewerMode}
                 label="Dual-stack&nbsp;"
+                callFormikOnChange={false}
+                onChange={() => setDualStack()}
               />
             </Tooltip>
           </SplitItem>
@@ -343,7 +338,7 @@ export const StackTypeControlGroup = ({
           titleIconVariant={'warning'}
           confirmationButtonText={'Change'}
           confirmationButtonVariant={ButtonVariant.primary}
-          content={<p>All data and configuration done for 'Dual-stack' will be lost.</p>}
+          content={<p>All data and configuration done for &apos;Dual-stack&apos; will be lost.</p>}
           onClose={() => {
             setConfirmModal(false);
             setDualStack();

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

@@ -53,11 +53,8 @@ import {
   NODE_HEALTHCHECK_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,
   SERVICE_MESH_OPERATOR_LINK,
@@ -183,11 +180,6 @@ export const getOperatorSpecs = (
         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} />{' '}
@@ -246,11 +238,6 @@ export const getOperatorSpecs = (
         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: ({ searchTerm }) => (
           <>
             <HighlightedText text={DESCRIPTION_OSC} searchTerm={searchTerm} />{' '}
@@ -266,9 +253,6 @@ export const getOperatorSpecs = (
         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} />{' '}

package/lib/common/config/docs_links.ts

@@ -118,7 +118,7 @@ export const getMceDocsLink = (ocpVersion?: string) =>
 export const getLvmsDocsLink = (ocpVersion?: string) =>
   `https://docs.redhat.com/en/documentation/openshift_container_platform/${getDocsOpenshiftVersion(
     ocpVersion,
-  )}/html/storage/configuring-persistent-storage#overview-of-lvm-storage-functionality_ways-to-provision-local-storage`;
+  )}/html-single/storage/index#persistent-storage-using-lvms`;
 
 export const NODE_HEALTHCHECK_LINK =
   'https://docs.redhat.com/en/documentation/workload_availability_for_red_hat_openshift/latest/html/remediation_fencing_and_maintenance/node-health-check-operator';
@@ -150,10 +150,11 @@ export const CHANGE_ISO_PASSWORD_FILE_LINK =
   'https://raw.githubusercontent.com/openshift/assisted-service/master/docs/change-iso-password.sh';
 
 export const getCiscoIntersightLink = (downloadIsoUrl: string, ciscoUrl?: string) => {
+  const isoUrl = encodeURIComponent(downloadIsoUrl);
   if (ciscoUrl) {
-    return `${ciscoUrl}?_workflow_Version=1&IsoUrl=${downloadIsoUrl}`;
+    return `${ciscoUrl}?_workflow_Version=1&IsoUrl=${isoUrl}`;
   }
-  return `https://www.intersight.com/an/workflow/workflow-definitions/execute/AddServersFromISO?_workflow_Version=1&IsoUrl=${downloadIsoUrl}`;
+  return `https://www.intersight.com/an/workflow/workflow-definitions/execute/AddServersFromISO?_workflow_Version=1&IsoUrl=${isoUrl}`;
 };
 
 export const MTV_LINK =
@@ -228,7 +229,7 @@ export const getClusterObservabilityLink = (ocpVersion?: string) =>
 export const getLokiLink = (ocpVersion?: string) =>
   `https://docs.redhat.com/en/documentation/openshift_container_platform/${getDocsOpenshiftVersion(
     ocpVersion,
-  )}/html/network_observability/network-observability-overview`;
+  )}/html/network_observability/installing-network-observability-operators#network-observability-loki-installation_network_observability`;
 
 export const getOpenShiftLoggingLink = (ocpVersion?: string) =>
   `https://docs.redhat.com/en/documentation/openshift_container_platform/${getDocsOpenshiftVersion(

package/lib/common/utils.ts

@@ -90,6 +90,9 @@ export const stringToJSON = <T>(jsonString: string | undefined): T | undefined =
 export const downloadFile = (fileUrl?: string, dataBlob?: Blob, fileName?: string) => {
   const link = document.createElement('a');
   if (fileUrl && fileUrl !== '') {
+    if (!/^(https?|blob):/i.test(fileUrl)) {
+      return;
+    }
     link.setAttribute('href', fileUrl);
   }
   if (dataBlob) {

package/lib/common/validationSchemas/addressValidation.tsx

@@ -9,7 +9,7 @@ import { HostSubnets, NetworkConfigurationValues } from '../types';
 import { IP_V4_ZERO, IP_V6_ZERO, MAC_REGEX } from './regexes';
 import { getArrayIndexFromPath, isIPorDN, isIPv4Address, isIPv6Address } from './utils';
 import { NO_SUBNET_SET } from '../config';
-import { overlap } from 'cidr-tools';
+import { overlapCidr } from 'cidr-tools';
 import parseUrl from 'parse-url';
 import { TFunction } from 'i18next';
 
@@ -272,7 +272,7 @@ export const ipBlockValidationSchema = (
     .test('cidrs-can-not-overlap', t('ai:Provided CIDRs can not overlap.'), (cidr: string) => {
       try {
         if (cidr && reservedCidrs && reservedCidrs.length > 0) {
-          return !overlap(cidr, reservedCidrs);
+          return !overlapCidr(cidr, reservedCidrs);
         }
       } catch {
         return false;

package/lib/ocm/components/Routes.tsx

@@ -7,7 +7,7 @@ import {
   Outlet,
   unstable_HistoryRouter as HistoryRouter,
   HistoryRouterProps,
-} from 'react-router-dom-v5-compat';
+} from 'react-router';
 import { Clusters, ClusterPage, NewClusterPage } from './clusters';
 import type { FeatureListType } from '../../common/features/featureGate';
 import { AssistedUILibVersion } from './ui';
@@ -39,7 +39,7 @@ export const UILibRoutes = ({
           <Route index element={<Clusters />} />
         </Route>
         {children}
-        <Route path="*" element={<Navigate to="assisted-installer/clusters" />} />
+        <Route path="*" element={<Navigate to="/assisted-installer/clusters" />} />
       </Routes>
     </>
   );

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

@@ -4,7 +4,7 @@ import {
   EventListFetchProps,
   getEnabledHosts,
   RenderIf,
-  selectOlmOperators,
+  selectAllOlmOperators,
 } from '../../../common';
 import { FinalizingProgress } from '../../../common/components/clusterDetail/FinalizingProgress';
 import { ProgressBarTexts } from '../../../common/components/clusterDetail/ProgressBarTexts';
@@ -26,7 +26,7 @@ const OcmClusterProgressItems = ({
   fallbackEventsURL,
 }: OcmClusterProgressItemsProps) => {
   const enabledHosts = getEnabledHosts(cluster.hosts);
-  const olmOperators = selectOlmOperators(cluster);
+  const olmOperators = selectAllOlmOperators(cluster);
 
   const masterHosts = enabledHosts.filter((host) => host.role && 'master' === host.role);
   const workerHosts = enabledHosts.filter((host) => host.role && 'worker' === host.role);

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

@@ -1,6 +1,6 @@
 import * as Yup from 'yup';
 import { TFunction } from 'i18next';
-import { CustomManifestValues, ManifestFormData } from '../data/dataTypes';
+import { CustomManifestValues } from '../data/dataTypes';
 import {
   getMaxFileSizeMessage,
   validateFileSize,
@@ -62,7 +62,7 @@ const INCORRECT_FILENAME =
 const UNIQUE_FOLDER_FILENAME = 'Ensure unique file names to avoid conflicts and errors.';
 
 export const getFormViewManifestsValidationSchema = (t: TFunction) =>
-  Yup.object<ManifestFormData>({
+  Yup.object({
     manifests: Yup.array<CustomManifestValues>()
       .of(
         Yup.object({

package/lib/ocm/components/clusterConfiguration/networkConfiguration/NetworkConfiguration.tsx

@@ -6,13 +6,16 @@ import {
   canBeDualStack,
   CpuArchitecture,
   DUAL_STACK,
+  getIPv6FromDualstack,
   HostSubnets,
   isAdvNetworkConf,
   isSNO,
   NetworkConfigurationValues,
+  NO_SUBNET_SET,
   selectApiVip,
   selectIngressVip,
 } from '../../../../common';
+import { Address6 } from 'ip-address';
 import {
   ManagedNetworkingControlGroup,
   UserManagedNetworkingTextContent,
@@ -36,6 +39,7 @@ import {
 } from '@openshift-assisted/types/assisted-installer-service';
 import useSupportLevelsAPI from '../../../hooks/useSupportLevelsAPI';
 import { isOciPlatformType } from '../../utils';
+import { useFeature } from '../../../hooks/use-feature';
 
 export type NetworkConfigurationProps = VirtualIPControlGroupProps & {
   hostSubnets: HostSubnets;
@@ -122,6 +126,33 @@ const getManagedNetworkingState = (
   };
 };
 
+type DefaultNetworkSettings = NetworkConfigurationProps['defaultNetworkSettings'];
+
+const getNetworkDefaultsByFamily = (
+  settings: DefaultNetworkSettings,
+  isDualStack: boolean,
+  isIPv6: boolean,
+) => {
+  if (isDualStack) {
+    return {
+      clusterNetworkDefaults: settings.clusterNetworksDualstack,
+      serviceNetworkDefaults: settings.serviceNetworksDualstack,
+    };
+  }
+  if (isIPv6) {
+    const ipv6Cluster = getIPv6FromDualstack(settings.clusterNetworksDualstack);
+    const ipv6Service = getIPv6FromDualstack(settings.serviceNetworksDualstack);
+    return {
+      clusterNetworkDefaults: ipv6Cluster ? [ipv6Cluster] : settings.clusterNetworksIpv4,
+      serviceNetworkDefaults: ipv6Service ? [ipv6Service] : settings.serviceNetworksIpv4,
+    };
+  }
+  return {
+    clusterNetworkDefaults: settings.clusterNetworksIpv4,
+    serviceNetworkDefaults: settings.serviceNetworksIpv4,
+  };
+};
+
 const NetworkConfiguration = ({
   cluster,
   hostSubnets,
@@ -136,8 +167,10 @@ const NetworkConfiguration = ({
     cluster.platform?.type,
   );
   const { isViewerMode } = useSelector(selectCurrentClusterPermissionsState);
-  const { setFieldValue, values, validateField } = useFormikContext<NetworkConfigurationValues>();
+  const { setFieldValue, values, validateField, validateForm } =
+    useFormikContext<NetworkConfigurationValues>();
 
+  const isSingleClusterFeature = useFeature('ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE');
   const isSNOCluster = isSNO(cluster);
   const isUserManagedNetworking = values.managedNetworkingType === 'userManaged';
   const isDualStack = values.stackType === DUAL_STACK;
@@ -177,30 +210,18 @@ const NetworkConfiguration = ({
       setAdvanced(checked);
 
       if (!checked) {
-        setFieldValue(
-          'clusterNetworks',
-          isDualStack
-            ? defaultNetworkSettings.clusterNetworksDualstack
-            : defaultNetworkSettings.clusterNetworksIpv4,
-          true,
-        );
-        setFieldValue(
-          'serviceNetworks',
-          isDualStack
-            ? defaultNetworkSettings.serviceNetworksDualstack
-            : defaultNetworkSettings.serviceNetworksIpv4,
-          true,
+        const primaryCidr = values.machineNetworks?.[0]?.cidr;
+        const isIPv6Stack = !!primaryCidr && Address6.isValid(primaryCidr);
+        const { clusterNetworkDefaults, serviceNetworkDefaults } = getNetworkDefaultsByFamily(
+          defaultNetworkSettings,
+          isDualStack,
+          isIPv6Stack,
         );
+        setFieldValue('clusterNetworks', clusterNetworkDefaults, true);
+        setFieldValue('serviceNetworks', serviceNetworkDefaults, true);
       }
     },
-    [
-      setFieldValue,
-      isDualStack,
-      defaultNetworkSettings.clusterNetworksDualstack,
-      defaultNetworkSettings.clusterNetworksIpv4,
-      defaultNetworkSettings.serviceNetworksDualstack,
-      defaultNetworkSettings.serviceNetworksIpv4,
-    ],
+    [setFieldValue, isDualStack, values.machineNetworks, defaultNetworkSettings],
   );
 
   React.useEffect(() => {
@@ -209,6 +230,47 @@ const NetworkConfiguration = ({
     }
   }, [isDualStack, isViewerMode, toggleAdvConfiguration]);
 
+  React.useEffect(() => {
+    if (!isSingleClusterFeature || isViewerMode || isDualStack || isAdvanced) {
+      return;
+    }
+    const primaryCidr = values.machineNetworks?.[0]?.cidr;
+    if (!primaryCidr || primaryCidr === NO_SUBNET_SET) {
+      return;
+    }
+    const isIPv6 = Address6.isValid(primaryCidr);
+    const currentClusterCidr = values.clusterNetworks?.[0]?.cidr;
+    const clusterIsIPv6 = currentClusterCidr ? Address6.isValid(currentClusterCidr) : null;
+
+    if (clusterIsIPv6 === isIPv6) {
+      return;
+    }
+
+    const { clusterNetworkDefaults, serviceNetworkDefaults } = getNetworkDefaultsByFamily(
+      defaultNetworkSettings,
+      false,
+      isIPv6,
+    );
+    if (clusterNetworkDefaults) {
+      setFieldValue('clusterNetworks', clusterNetworkDefaults);
+    }
+    if (serviceNetworkDefaults) {
+      setFieldValue('serviceNetworks', serviceNetworkDefaults);
+    }
+    void validateForm();
+  }, [
+    isSingleClusterFeature,
+    isViewerMode,
+    isDualStack,
+    isAdvanced,
+    values.machineNetworks,
+    values.clusterNetworks,
+    defaultNetworkSettings,
+    setFieldValue,
+    validateForm,
+    cluster.id,
+  ]);
+
   const managedNetworkingState = React.useMemo(
     () =>
       getManagedNetworkingState(
@@ -252,6 +314,7 @@ const NetworkConfiguration = ({
             hostSubnets={hostSubnets}
             defaultNetworkValues={defaultNetworkSettings}
             isViewerMode={isViewerMode}
+            allowSingleStackIPv6={isSingleClusterFeature}
           />
         </StackItem>
       )}
@@ -277,6 +340,7 @@ const NetworkConfiguration = ({
             }
             openshiftVersion={cluster.openshiftVersion}
             isViewerMode={isViewerMode}
+            allowSingleStackIPv6={isSingleClusterFeature}
           />
         </StackItem>
       )}

package/lib/ocm/components/clusterConfiguration/networkConfiguration/NetworkConfigurationForm.tsx

@@ -9,7 +9,7 @@ import {
   getFormikErrorFields,
   getHostSubnets,
   HostSubnets,
-  SINGLE_STACK,
+  DUAL_STACK,
   isSNO,
   LoadingState,
   NetworkConfigurationValues,
@@ -262,7 +262,7 @@ const NetworkConfigurationPage = ({ cluster }: { cluster: Cluster }) => {
         if (values.vipDhcpAllocation) {
           delete params.apiVips;
           delete params.ingressVips;
-        } else if (values.stackType === SINGLE_STACK) {
+        } else if (values.stackType !== DUAL_STACK) {
           // The API will rebuild the default machineNetwork
           params.machineNetworks = [];
         }