@atlaskit/radio 8.4.6 → 8.5.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @atlaskit/radio
 
+## 8.5.0
+
+### Minor Changes
+
+- [`e1feac98875c6`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/e1feac98875c6) -
+  Internal only CSS refactor to eliminate nested CSS selectors in favor of an atomic-friendly
+  styling approach. This change was previously behind the `platform-radio-atomic-styles` feature
+  gate, which has now been removed.
+
+### Patch Changes
+
+- [`02483200273ec`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/02483200273ec) -
+  Enrol all Design System UI packages into the React Compiler with platform gating via
+  isReactCompilerActivePlatform.
+- Updated dependencies
+
+## 8.4.7
+
+### Patch Changes
+
+- [`e2085d35701ca`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/e2085d35701ca) -
+  Internal changes to remove unnecessary token fallbacks and imports from `@atlaskit/theme`
+- Updated dependencies
+
 ## 8.4.6
 
 ### Patch Changes

package/codemods/add-comment-before.tsx

@@ -0,0 +1,40 @@
+import { type ASTPath, type ImportDeclaration, type JSCodeshift, type Program } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+// not replacing newlines (which \s does)
+const spacesAndTabs: RegExp = /[ \t]{2,}/g;
+const lineStartWithSpaces: RegExp = /^[ \t]*/gm;
+
+function clean(value: string): string {
+	return (
+		value
+			.replace(spacesAndTabs, ' ')
+			.replace(lineStartWithSpaces, '')
+			// using .trim() to clear the any newlines before the first text and after last text
+			.trim()
+	);
+}
+
+export function addCommentBefore({
+	j,
+	target,
+	message,
+}: {
+	j: JSCodeshift;
+	target: Collection<Program> | Collection<ImportDeclaration>;
+	message: string;
+}): void {
+	const content: string = ` TODO: (from codemod) ${clean(message)} `;
+	target.forEach((path: ASTPath<Program | ImportDeclaration>) => {
+		path.value.comments = path.value.comments || [];
+
+		const exists = path.value.comments.find((comment) => comment.value === content);
+
+		// avoiding duplicates of the same comment
+		if (exists) {
+			return;
+		}
+
+		path.value.comments.push(j.commentBlock(content));
+	});
+}

package/codemods/add-comment-to-start-of-file.tsx

@@ -0,0 +1,20 @@
+import { type JSCodeshift } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+import { addCommentBefore } from './add-comment-before';
+
+export function addCommentToStartOfFile({
+	j,
+	base,
+	message,
+}: {
+	j: JSCodeshift;
+	base: Collection<Node>;
+	message: string;
+}): void {
+	addCommentBefore({
+		j,
+		target: base.find(j.Program),
+		message,
+	});
+}

package/codemods/add-to-import.tsx

@@ -0,0 +1,32 @@
+import { type ImportDefaultSpecifier, type ImportSpecifier, type JSCodeshift } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+export function addToImport({
+	j,
+	base,
+	importSpecifier,
+	packageName,
+}: {
+	j: JSCodeshift;
+	base: Collection<any>;
+	importSpecifier: ImportSpecifier | ImportDefaultSpecifier;
+	packageName: string;
+}): void {
+	base
+		.find(j.ImportDeclaration)
+		.filter((path) => path.value.source.value === packageName)
+		.replaceWith((declaration) => {
+			return j.importDeclaration(
+				[
+					// we are appending to the existing specifiers
+					// We are doing a filter hear because sometimes specifiers can be removed
+					// but they hand around in the declaration
+					...(declaration.value.specifiers || []).filter(
+						(item) => item.type === 'ImportSpecifier' && item.imported != null,
+					),
+					importSpecifier,
+				],
+				j.literal(packageName),
+			);
+		});
+}

package/codemods/create-remove-func-for.tsx

@@ -0,0 +1,44 @@
+import { type ASTPath, type ImportDeclaration, type JSCodeshift } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+import { addCommentToStartOfFile } from './add-comment-to-start-of-file';
+import { getJSXAttributesByName } from './get-jsx-attributes-by-name';
+import { getNamedSpecifier } from './get-named-specifier';
+
+function getDefaultSpecifier(j: JSCodeshift, source: ReturnType<typeof j>, specifier: string) {
+	const specifiers = source
+		.find(j.ImportDeclaration)
+		.filter((path: ASTPath<ImportDeclaration>) => path.node.source.value === specifier)
+		.find(j.ImportDefaultSpecifier);
+
+	if (!specifiers.length) {
+		return null;
+	}
+	return specifiers.nodes()[0]!.local!.name;
+}
+
+export const createRemoveFuncFor: (
+	component: string,
+	importName: string,
+	prop: string,
+	comment?: string,
+) => (j: JSCodeshift, source: Collection<Node>) => void =
+	(component: string, importName: string, prop: string, comment?: string) =>
+	(j: JSCodeshift, source: Collection<Node>) => {
+		const specifier =
+			getNamedSpecifier(j, source, component, importName) ||
+			getDefaultSpecifier(j, source, component);
+
+		if (!specifier) {
+			return;
+		}
+
+		source.findJSXElements(specifier).forEach((element) => {
+			getJSXAttributesByName(j, element, prop).forEach((attribute) => {
+				j(attribute).remove();
+				if (comment) {
+					addCommentToStartOfFile({ j, base: source, message: comment });
+				}
+			});
+		});
+	};

package/codemods/create-remove-imports-for.tsx

@@ -0,0 +1,83 @@
+import { type JSCodeshift } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+import { addCommentToStartOfFile } from './add-comment-to-start-of-file';
+import { type Nullable } from './types';
+
+export const createRemoveImportsFor: ({
+	importsToRemove,
+	packagePath,
+	comment,
+}: {
+	importsToRemove: string[];
+	packagePath: string;
+	comment: string;
+}) => (j: JSCodeshift, source: Collection<Node>) => void =
+	({
+		importsToRemove,
+		packagePath,
+		comment,
+	}: {
+		importsToRemove: string[];
+		packagePath: string;
+		comment: string;
+	}) =>
+	(j: JSCodeshift, source: Collection<Node>) => {
+		const isUsingName: boolean =
+			source.find(j.ImportDeclaration).filter((path) => path.node.source.value === packagePath)
+				.length > 0;
+		if (!isUsingName) {
+			return;
+		}
+
+		const existingAlias: Nullable<string> =
+			source
+				.find(j.ImportDeclaration)
+				.filter((path) => path.node.source.value === packagePath)
+				.find(j.ImportSpecifier)
+				.nodes()
+				.map((specifier): Nullable<string> => {
+					if (!importsToRemove.includes(specifier.imported.name)) {
+						return null;
+					}
+					// If aliased: return the alias
+					if (specifier.local && !importsToRemove.includes(specifier.local.name)) {
+						return specifier.local.name;
+					}
+
+					return null;
+				})
+				.filter(Boolean)[0] || null;
+
+		// Remove imports
+		source
+			.find(j.ImportDeclaration)
+			.filter((path) => path.node.source.value === packagePath)
+			.find(j.ImportSpecifier)
+			.find(j.Identifier)
+			.filter((identifier) => {
+				if (
+					importsToRemove.includes(identifier.value.name) ||
+					identifier.value.name === existingAlias
+				) {
+					addCommentToStartOfFile({ j, base: source, message: comment });
+					return true;
+				}
+				return false;
+			})
+			.remove();
+
+		// Remove entire import if it is empty
+		const isEmptyImport =
+			source
+				.find(j.ImportDeclaration)
+				.filter((path) => path.node.source.value === packagePath)
+				.find(j.ImportSpecifier)
+				.find(j.Identifier).length === 0;
+		if (isEmptyImport) {
+			source
+				.find(j.ImportDeclaration)
+				.filter((path) => path.node.source.value === packagePath)
+				.remove();
+		}
+	};

package/codemods/create-rename-func-for.tsx

@@ -0,0 +1,26 @@
+import { type JSCodeshift } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+import { getJSXAttributesByName } from './get-jsx-attributes-by-name';
+import { getNamedSpecifier } from './get-named-specifier';
+
+export const createRenameFuncFor: (
+	component: string,
+	importName: string,
+	from: string,
+	to: string,
+) => (j: JSCodeshift, source: Collection<Node>) => void =
+	(component: string, importName: string, from: string, to: string) =>
+	(j: JSCodeshift, source: Collection<Node>) => {
+		const specifier = getNamedSpecifier(j, source, component, importName);
+
+		if (!specifier) {
+			return;
+		}
+
+		source.findJSXElements(specifier).forEach((element) => {
+			getJSXAttributesByName(j, element, from).forEach((attribute) => {
+				j(attribute).replaceWith(j.jsxAttribute(j.jsxIdentifier(to), attribute.node.value));
+			});
+		});
+	};

package/codemods/create-rename-import-for.tsx

@@ -0,0 +1,97 @@
+import { type ImportDefaultSpecifier, type ImportSpecifier, type JSCodeshift } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+import { addToImport } from './add-to-import';
+import { tryCreateImport } from './try-create-import';
+import { type Nullable } from './types';
+
+export const createRenameImportFor: ({
+	componentName,
+	newComponentName,
+	oldPackagePath,
+	newPackagePath,
+}: {
+	componentName: string;
+	newComponentName?: string;
+	oldPackagePath: string;
+	newPackagePath: string;
+}) => (j: JSCodeshift, source: Collection<Node>) => void =
+	({
+		componentName,
+		newComponentName,
+		oldPackagePath,
+		newPackagePath,
+	}: {
+		componentName: string;
+		newComponentName?: string;
+		oldPackagePath: string;
+		newPackagePath: string;
+	}) =>
+	(j: JSCodeshift, source: Collection<Node>) => {
+		const isUsingName: boolean =
+			source
+				.find(j.ImportDeclaration)
+				.filter((path) => path.node.source.value === oldPackagePath)
+				.find(j.ImportSpecifier)
+				.nodes()
+				.filter((specifier) => specifier.imported && specifier.imported.name === componentName)
+				.length > 0;
+		if (!isUsingName) {
+			return;
+		}
+
+		const existingAlias: Nullable<string> =
+			source
+				.find(j.ImportDeclaration)
+				.filter((path) => path.node.source.value === oldPackagePath)
+				.find(j.ImportSpecifier)
+				.nodes()
+				.map((specifier): Nullable<string> => {
+					if (specifier.imported && specifier.imported.name !== componentName) {
+						return null;
+					}
+					// If aliased: return the alias
+					if (specifier.local && specifier.local.name !== componentName) {
+						return specifier.local.name;
+					}
+
+					return null;
+				})
+				.filter(Boolean)[0] || null;
+
+		// Check to see if need to create new package path
+		// Try create an import declaration just before the old import
+		tryCreateImport({
+			j,
+			base: source,
+			relativeToPackage: oldPackagePath,
+			packageName: newPackagePath,
+		});
+
+		const newSpecifier: ImportSpecifier | ImportDefaultSpecifier = (() => {
+			// If there's a new name use that
+			if (newComponentName) {
+				return j.importSpecifier(j.identifier(newComponentName), j.identifier(newComponentName));
+			}
+
+			if (existingAlias) {
+				return j.importSpecifier(j.identifier(componentName), j.identifier(existingAlias));
+			}
+
+			// Add specifier
+			return j.importSpecifier(j.identifier(componentName), j.identifier(componentName));
+		})();
+
+		addToImport({
+			j,
+			base: source,
+			importSpecifier: newSpecifier,
+			packageName: newPackagePath,
+		});
+
+		// Remove old path
+		source
+			.find(j.ImportDeclaration)
+			.filter((path) => path.node.source.value === oldPackagePath)
+			.remove();
+	};

package/codemods/create-transformer.tsx

@@ -0,0 +1,23 @@
+import { type API, type FileInfo, type JSCodeshift, type Options } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+import { hasImportDeclaration } from './has-import-declaration';
+
+export const createTransformer: (
+	component: string,
+	migrates: {
+		(j: JSCodeshift, source: Collection<Node>): void;
+	}[],
+) => (fileInfo: FileInfo, api: API, options: Options) => string =
+	(component: string, migrates: { (j: JSCodeshift, source: Collection<Node>): void }[]) =>
+	(fileInfo: FileInfo, { jscodeshift: j }: API, options: Options) => {
+		const source: Collection<Node> = j(fileInfo.source);
+
+		if (!hasImportDeclaration(j, source, component)) {
+			return fileInfo.source;
+		}
+
+		migrates.forEach((tf) => tf(j, source));
+
+		return source.toSource(options.printOptions || { quote: 'single' });
+	};

package/codemods/find-identifier-and-replace-attribute.tsx

@@ -0,0 +1,27 @@
+import { type JSCodeshift } from 'jscodeshift';
+
+export function findIdentifierAndReplaceAttribute(
+	j: JSCodeshift,
+	source: ReturnType<typeof j>,
+	identifierName: string,
+	searchAttr: string,
+	replaceWithAttr: string,
+): void {
+	source
+		.find(j.JSXElement)
+		.find(j.JSXOpeningElement)
+		.filter((path) => {
+			return !!j(path.node)
+				.find(j.JSXIdentifier)
+				.filter((identifier) => identifier.value.name === identifierName);
+		})
+		.forEach((element) => {
+			j(element)
+				.find(j.JSXAttribute)
+				.find(j.JSXIdentifier)
+				.filter((attr) => attr.node.name === searchAttr)
+				.forEach((attribute) => {
+					j(attribute).replaceWith(j.jsxIdentifier(replaceWithAttr));
+				});
+		});
+}

package/codemods/get-jsx-attributes-by-name.tsx

@@ -0,0 +1,18 @@
+import { type ASTPath, type JSCodeshift, type JSXAttribute } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+export function getJSXAttributesByName(
+	j: JSCodeshift,
+	element: ASTPath<any>,
+	attributeName: string,
+): Collection<JSXAttribute> {
+	return j(element)
+		.find(j.JSXOpeningElement)
+		.find(j.JSXAttribute)
+		.filter((attribute) => {
+			const matches = j(attribute)
+				.find(j.JSXIdentifier)
+				.filter((identifier) => identifier.value.name === attributeName);
+			return Boolean(matches.length);
+		});
+}

package/codemods/get-named-specifier.tsx

@@ -0,0 +1,24 @@
+import {
+	type ASTPath,
+	type ImportDeclaration,
+	type ImportSpecifier,
+	type JSCodeshift,
+} from 'jscodeshift';
+
+export function getNamedSpecifier(
+	j: JSCodeshift,
+	source: any,
+	specifier: string,
+	importName: string,
+): any {
+	const specifiers = source
+		.find(j.ImportDeclaration)
+		.filter((path: ASTPath<ImportDeclaration>) => path.node.source.value === specifier)
+		.find(j.ImportSpecifier)
+		.filter((path: ASTPath<ImportSpecifier>) => path.node.imported.name === importName);
+
+	if (!specifiers.length) {
+		return null;
+	}
+	return specifiers.nodes()[0]!.local!.name;
+}

package/codemods/has-import-declaration.tsx

@@ -0,0 +1,12 @@
+import { type ASTPath, type ImportDeclaration, type JSCodeshift } from 'jscodeshift';
+
+export function hasImportDeclaration(j: JSCodeshift, source: any, importPath: string): boolean {
+	const imports = source
+		.find(j.ImportDeclaration)
+		.filter(
+			(path: ASTPath<ImportDeclaration>) =>
+				typeof path.node.source.value === 'string' && path.node.source.value.startsWith(importPath),
+		);
+
+	return Boolean(imports.length);
+}

package/codemods/has-variable-assignment.tsx

@@ -0,0 +1,18 @@
+import { type JSCodeshift, type VariableDeclaration } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+export function hasVariableAssignment(
+	j: JSCodeshift,
+	source: ReturnType<typeof j>,
+	identifierName: string,
+): Collection<VariableDeclaration> | boolean {
+	const occurance = source.find(j.VariableDeclaration).filter((path) => {
+		return !!j(path.node)
+			.find(j.VariableDeclarator)
+			.find(j.Identifier)
+			.filter((identifier) => {
+				return identifier.node.name === identifierName;
+			}).length;
+	});
+	return !!occurance.length ? occurance : false;
+}

package/codemods/migrations/migrate-radio-aria-labelledby.tsx

@@ -0,0 +1,6 @@
+import { createRenameFuncFor } from '../create-rename-func-for';
+
+export const migrateRadioAriaLabelledby: (
+	j: import('jscodeshift/src/core').JSCodeshift,
+	source: import('jscodeshift/src/Collection').Collection<Node>,
+) => void = createRenameFuncFor('@atlaskit/radio', 'Radio', 'aria-labelledby', 'labelId');

package/codemods/migrations/migrate-radio-group-aria-labelledby.tsx

@@ -0,0 +1,6 @@
+import { createRenameFuncFor } from '../create-rename-func-for';
+
+export const migrateRadioGroupAriaLabelledby: (
+	j: import('jscodeshift/src/core').JSCodeshift,
+	source: import('jscodeshift/src/Collection').Collection<Node>,
+) => void = createRenameFuncFor('@atlaskit/radio', 'RadioGroup', 'aria-labelledby', 'labelId');

package/codemods/not-yet-migrate-aria-labelledby.tsx

@@ -1,10 +1,8 @@
 import type { API, FileInfo, Options } from 'jscodeshift';
 
-import {
-	migrateRadioAriaLabelledby,
-	migrateRadioGroupAriaLabelledby,
-} from './migrations/migrate-aria-labelledby';
-import { createTransformer } from './utils';
+import { createTransformer } from './create-transformer';
+import { migrateRadioAriaLabelledby } from './migrations/migrate-radio-aria-labelledby';
+import { migrateRadioGroupAriaLabelledby } from './migrations/migrate-radio-group-aria-labelledby';
 
 const transformer: (fileInfo: FileInfo, { jscodeshift }: API, options: Options) => string =
 	createTransformer('@atlaskit/radio', [

package/codemods/try-create-import.tsx

@@ -0,0 +1,27 @@
+import { type JSCodeshift } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
+
+export function tryCreateImport({
+	j,
+	base,
+	relativeToPackage,
+	packageName,
+}: {
+	j: JSCodeshift;
+	base: Collection<any>;
+	relativeToPackage: string;
+	packageName: string;
+}): void {
+	const exists: boolean =
+		base.find(j.ImportDeclaration).filter((path) => path.value.source.value === packageName)
+			.length > 0;
+
+	if (exists) {
+		return;
+	}
+
+	base
+		.find(j.ImportDeclaration)
+		.filter((path) => path.value.source.value === relativeToPackage)
+		.insertBefore(j.importDeclaration([], j.literal(packageName)));
+}

package/codemods/types.tsx

@@ -0,0 +1 @@
+export type Nullable<T> = T | null;

package/dist/cjs/radio.compiled.css

@@ -14,15 +14,10 @@
 ._12ji1r31{outline-color:currentColor}
 ._12y31o36{outline-width:medium}
 ._13diglyw{-moz-appearance:none}
-._17a1bk0g:disabled[data-invalid]{--radio-border-color:var(--ds-border-disabled,#0515240f)}
 ._18postnw:after{position:absolute}
-._19ybs4qr:checked[data-invalid]{--radio-border-color:var(--ds-icon-danger,#c9372c)}
 ._1bah1h6o{justify-content:center}
 ._1bsb1tcg{width:24px}
-._1d7ps4qr[data-invalid]{--radio-border-color:var(--ds-icon-danger,#c9372c)}
 ._1e0c1txw{display:flex}
-._1el2by5v:disabled[data-invalid]{--radio-background-color:var(--ds-background-disabled,#17171708)}
-._1if1bk0g:disabled:checked{--radio-border-color:var(--ds-border-disabled,#0515240f)}
 ._1o9zidpf{flex-shrink:0}
 ._1peq1xmd:after{opacity:var(--radio-dot-opacity)}
 ._1q51v77o{padding-block-start:var(--ds-space-025,2px)}
@@ -32,26 +27,17 @@
 ._1qu2glyw{outline-style:none}
 ._1s6w2sac{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
 ._1s6w5w2r{--radio-dot-color:var(--ds-icon-inverse,#fff)}
-._2kbkby5v:disabled:checked{--radio-background-color:var(--ds-background-disabled,#17171708)}
 ._4cvr1h6o{align-items:center}
 ._4cvr1y6m{align-items:flex-start}
-._4fps13gf:disabled:checked{cursor:not-allowed}
-._4ryaby5v:disabled{--radio-background-color:var(--ds-background-disabled,#17171708)}
 ._4t3i1tcg{height:24px}
-._6hp813gf:disabled[data-invalid]{cursor:not-allowed}
 ._80om13gf{cursor:not-allowed}
 ._85i5v77o{padding-block-end:var(--ds-space-025,2px)}
 ._aetrb3bt:after{content:""}
 ._bfhk4t47{background-color:var(--radio-background-color)}
 ._bozg1b66{padding-inline-start:var(--ds-space-050,4px)}
 ._f3ett94y:checked{--radio-dot-opacity:1px}
-._g7st13gf[data-disabled]{cursor:not-allowed}
 ._iosijmqp:checked{--radio-background-color:var(--ds-background-selected-bold,#1868db)}
-._j5dh13gf:disabled{cursor:not-allowed}
 ._kqswh2mm{position:relative}
-._lekrbk0g:disabled{--radio-border-color:var(--ds-border-disabled,#0515240f)}
-._mqf81gmx[data-disabled]{color:var(--ds-text-disabled,#080f214a)}
-._pmm42sac:disabled[data-invalid]{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
 ._s7n4jp4b{vertical-align:top}
 ._syaz1gmx{color:var(--ds-text-disabled,#080f214a)}
 ._syazi7uo{color:var(--ds-text,#292a2e)}
@@ -59,44 +45,18 @@
 ._tqbwidpf{--radio-dot-opacity:0}
 ._tqbwt94y{--radio-dot-opacity:1px}
 ._vchhusvi{box-sizing:border-box}
-._wml02sac:disabled:checked{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
 ._wstuglyw{-webkit-appearance:none}
-._x48a2sac:disabled{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
 ._y4ti1b66{padding-inline-end:var(--ds-space-050,4px)}
 ._z0ai120g:after{width:.6pc}
-._6tjkjsth:checked:focus{outline:var(--ds-border-width-focused,3px) solid var(--ds-border-focused,#4688ec)}
-._y2mvjsth:focus{outline:var(--ds-border-width-focused,3px) solid var(--ds-border-focused,#4688ec)}
+._6tjkdfik:checked:focus{outline:var(--ds-border-width-focused,2px) solid var(--ds-border-focused,#4688ec)}
+._y2mvdfik:focus{outline:var(--ds-border-width-focused,2px) solid var(--ds-border-focused,#4688ec)}
 ._1bg41l7b:focus{outline-offset:3px}
-._1c6f2sac:disabled:checked:focus{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
-._1f8cbk0g:disabled:focus{--radio-border-color:var(--ds-border-disabled,#0515240f)}
-._1gcs13gf:disabled:focus{cursor:not-allowed}
-._1yk92sac:disabled:focus{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
-._92nabk0g:disabled:checked:focus{--radio-border-color:var(--ds-border-disabled,#0515240f)}
 ._awqn1l7b:checked:focus{outline-offset:3px}
-._n8t0by5v:disabled:checked:focus{--radio-background-color:var(--ds-background-disabled,#17171708)}
-._nxi6by5v:disabled:focus{--radio-background-color:var(--ds-background-disabled,#17171708)}
-._qep213gf:disabled:checked:focus{cursor:not-allowed}
-._180n13gf:disabled:checked:hover{cursor:not-allowed}
 ._1iwz1q28:checked:hover{--radio-border-color:var(--ds-background-selected-bold-hovered,#1558bc)}
-._1o5rby5v:disabled:checked:hover{--radio-background-color:var(--ds-background-disabled,#17171708)}
 ._1p9jrsbi:hover{--radio-border-color:var(--ds-border-input,#8c8f97)}
 ._1rvql4ek:hover{--radio-background-color:var(--ds-background-input-hovered,#f8f8f8)}
-._1x1a13gf:disabled:hover{cursor:not-allowed}
-._awurbk0g:disabled:checked:hover{--radio-border-color:var(--ds-border-disabled,#0515240f)}
-._gdmb2sac:disabled:hover{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
-._neoeby5v:disabled:hover{--radio-background-color:var(--ds-background-disabled,#17171708)}
-._qftt2sac:disabled:checked:hover{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
-._s2ftbk0g:disabled:hover{--radio-border-color:var(--ds-border-disabled,#0515240f)}
 ._x2tz1q28:checked:hover{--radio-background-color:var(--ds-background-selected-bold-hovered,#1558bc)}
-._11v7bk0g:disabled:active{--radio-border-color:var(--ds-border-disabled,#0515240f)}
 ._1dvdrsbi:checked:active{--radio-border-color:var(--ds-border-input,#8c8f97)}
-._1ib22sac:disabled:active{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
-._5ry313gf:disabled:checked:active{cursor:not-allowed}
 ._60ak5w2r:checked:active{--radio-dot-color:var(--ds-icon-inverse,#fff)}
-._6cyrby5v:disabled:checked:active{--radio-background-color:var(--ds-background-disabled,#17171708)}
-._bl0ebk0g:disabled:checked:active{--radio-border-color:var(--ds-border-disabled,#0515240f)}
 ._jcko12kk:checked:active{--radio-background-color:var(--ds-background-selected-bold-pressed,#123263)}
-._o1bdby5v:disabled:active{--radio-background-color:var(--ds-background-disabled,#17171708)}
-._scgf13gf:disabled:active{cursor:not-allowed}
-._sj8yr01l:active{--radio-background-color:var(--ds-background-input-pressed,#fff)}
-._tusm2sac:disabled:checked:active{--radio-dot-color:var(--ds-icon-disabled,#080f214a)}
+._sj8yr01l:active{--radio-background-color:var(--ds-background-input-pressed,#fff)}