consistent-boolean-name: Rename booleanWrappers option

Fixes #3556

Author: sindresorhus

docs/rules/consistent-boolean-name.md

@@ -233,7 +233,7 @@ And this would fail:
 const didUpdate = true;
 ```
 
-### booleanWrappers
+### wrappers
 
 Type: `Record<string, string>`\
 Default: `{}`
@@ -244,7 +244,7 @@ Map unqualified TypeScript wrapper type names to the property or method that pro
 'unicorn/consistent-boolean-name': [
 	'error',
 	{
-		booleanWrappers: {
+		wrappers: {
 			StorageItem: 'get',
 		},
 	},

rules/consistent-boolean-name.js

@@ -144,12 +144,12 @@ const prepareOptions = ({
 	checkProperties = false,
 	prefixes = {},
 	ignore = [],
-	booleanWrappers = {},
+	wrappers = {},
 } = {}) => ({
 	checkProperties,
 	prefixes: getEnabledPrefixes({prefixes}),
 	ignore: ignore.map(pattern => isRegExp(pattern) ? pattern : new RegExp(pattern, 'u')),
-	booleanWrappers: new Map(Object.entries(booleanWrappers)),
+	wrappers: new Map(Object.entries(wrappers)),
 });
 
 function isIgnoredName(name, ignore) {
@@ -1199,7 +1199,7 @@ function getAutofix({
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const {checkProperties, prefixes, ignore, booleanWrappers} = prepareOptions(context.options[0]);
+	const {checkProperties, prefixes, ignore, wrappers} = prepareOptions(context.options[0]);
 
 	if (prefixes.length === 0) {
 		return;
@@ -1217,13 +1217,13 @@ const create = context => {
 		const booleanPrefix = getBooleanPrefix(nameForPrefixCheck, prefixes);
 		if (booleanPrefix) {
 			const booleanState = getVariableBooleanState(variable, context);
-			const booleanWrapperState = booleanWrappers.size === 0 || booleanState === boolean
+			const booleanWrapperState = wrappers.size === 0 || booleanState === boolean
 				? unknown
 				: getBooleanWrapperVariableState({
 					variable,
 					definition: getSupportedVariableDefinition(variable),
 					context,
-					booleanWrappers,
+					wrappers,
 				});
 			const effectiveBooleanState = booleanWrapperState === unknown ? booleanState : booleanWrapperState;
 			if (
@@ -1378,7 +1378,7 @@ const config = {
 							pattern: '^[a-z][a-zA-Z0-9]*$',
 						},
 					},
-					booleanWrappers: {
+					wrappers: {
 						type: 'object',
 						description: 'Wrapper type names and their boolean-like value members.',
 						additionalProperties: {
@@ -1395,7 +1395,7 @@ const config = {
 				},
 			},
 		],
-		defaultOptions: [{ignore: [], booleanWrappers: {}}],
+		defaultOptions: [{ignore: [], wrappers: {}}],
 		messages,
 		languages: [
 			'js/js',

rules/utils/get-boolean-wrapper-variable-state.js

@@ -10,14 +10,14 @@ const mappedTypeFlag = 32;
 
 const isMappedType = type => (type.objectFlags % (mappedTypeFlag * 2)) >= mappedTypeFlag;
 
-function getConfiguredMemberName(type, checker, booleanWrappers, visitedTypes = new Set()) {
+function getConfiguredMemberName(type, checker, wrappers, visitedTypes = new Set()) {
 	if (!type) {
 		return;
 	}
 
 	const nonNullableType = checker.getNonNullableType(type);
 	if (nonNullableType !== type) {
-		return getConfiguredMemberName(nonNullableType, checker, booleanWrappers, visitedTypes);
+		return getConfiguredMemberName(nonNullableType, checker, wrappers, visitedTypes);
 	}
 
 	if (visitedTypes.has(type)) {
@@ -32,19 +32,19 @@ function getConfiguredMemberName(type, checker, booleanWrappers, visitedTypes =
 		type.target?.symbol?.name,
 	];
 	const memberName = typeNames
-		.map(typeName => booleanWrappers.get(typeName))
+		.map(typeName => wrappers.get(typeName))
 		.find(Boolean);
 	if (memberName) {
 		return memberName;
 	}
 
 	if (isTypeParameterType(type)) {
-		return getConfiguredMemberName(type.getConstraint(), checker, booleanWrappers, visitedTypes);
+		return getConfiguredMemberName(type.getConstraint(), checker, wrappers, visitedTypes);
 	}
 
 	if (type.isIntersection()) {
 		for (const constituentType of type.types) {
-			const memberName = getConfiguredMemberName(constituentType, checker, booleanWrappers, visitedTypes);
+			const memberName = getConfiguredMemberName(constituentType, checker, wrappers, visitedTypes);
 			if (memberName) {
 				return memberName;
 			}
@@ -53,15 +53,15 @@ function getConfiguredMemberName(type, checker, booleanWrappers, visitedTypes =
 
 	if (isMappedType(type)) {
 		for (const typeArgument of type.aliasTypeArguments ?? []) {
-			const memberName = getConfiguredMemberName(typeArgument, checker, booleanWrappers, visitedTypes);
+			const memberName = getConfiguredMemberName(typeArgument, checker, wrappers, visitedTypes);
 			if (memberName) {
 				return memberName;
 			}
 		}
 	}
 
 	for (const baseType of getBaseTypes(type, checker)) {
-		const memberName = getConfiguredMemberName(baseType, checker, booleanWrappers, visitedTypes);
+		const memberName = getConfiguredMemberName(baseType, checker, wrappers, visitedTypes);
 		if (memberName) {
 			return memberName;
 		}
@@ -96,31 +96,31 @@ function getBooleanWrapperMemberState(type, memberName, checker) {
 		: getBooleanValueState(memberType, checker);
 }
 
-function getBooleanWrapperTypeState(type, checker, booleanWrappers) {
+function getBooleanWrapperTypeState(type, checker, wrappers) {
 	if (!type) {
 		return unknown;
 	}
 
 	const nonNullableType = checker.getNonNullableType(type);
 	if (nonNullableType !== type) {
-		return getBooleanWrapperTypeState(nonNullableType, checker, booleanWrappers);
+		return getBooleanWrapperTypeState(nonNullableType, checker, wrappers);
 	}
 
 	if (type.isUnion()) {
-		return combineBooleanStates(type.types.map(type => getBooleanWrapperTypeState(type, checker, booleanWrappers)));
+		return combineBooleanStates(type.types.map(type => getBooleanWrapperTypeState(type, checker, wrappers)));
 	}
 
-	const memberName = getConfiguredMemberName(type, checker, booleanWrappers);
+	const memberName = getConfiguredMemberName(type, checker, wrappers);
 	if (!memberName) {
 		return unknown;
 	}
 
 	return getBooleanWrapperMemberState(type, memberName, checker);
 }
 
-function getBooleanWrapperVariableState({variable, definition, context, booleanWrappers}) {
+function getBooleanWrapperVariableState({variable, definition, context, wrappers}) {
 	if (
-		booleanWrappers.size === 0
+		wrappers.size === 0
 		|| !definition
 		|| !['Variable', 'Parameter'].includes(definition.type)
 		|| variable.references.some(reference => !reference.init && reference.isWrite())
@@ -137,7 +137,7 @@ function getBooleanWrapperVariableState({variable, definition, context, booleanW
 		return getBooleanWrapperTypeState(
 			parserServices.getTypeAtLocation(definition.name),
 			parserServices.program.getTypeChecker(),
-			booleanWrappers,
+			wrappers,
 		);
 	} catch {
 		return unknown;

test/consistent-boolean-name-boolean-wrappers.js

@@ -36,7 +36,7 @@ const typeAware = testCase => {
 };
 
 const booleanWrapperOptions = {
-	booleanWrappers: {
+	wrappers: {
 		StorageItem: 'get',
 	},
 };
@@ -76,12 +76,12 @@ test({
 		validBooleanWrapper(`${storageItemType} type ReadonlyStorageItem = Readonly<StorageItem<unknown, boolean>>; declare const isUnicorn: ReadonlyStorageItem;`),
 		validBooleanWrapper(`${storageItemType} declare function createStorageItem(): StorageItem<boolean>; const isUnicorn = createStorageItem();`),
 		validBooleanWrapper(`${storageItemType} function useStorage<T extends StorageItem<boolean>>(isUnicorn: T) {}`),
-		validBooleanWrapper('interface BooleanWrapper {value: boolean} declare const isReady: BooleanWrapper;', {booleanWrappers: {BooleanWrapper: 'value'}}),
-		validBooleanWrapper('interface DirectBooleanMethodWrapper {get(): boolean} declare const isReady: DirectBooleanMethodWrapper;', {booleanWrappers: {DirectBooleanMethodWrapper: 'get'}}),
-		validBooleanWrapper('interface BooleanWrapper {get(): boolean} declare const ready: BooleanWrapper;', {booleanWrappers: {BooleanWrapper: 'get'}}),
-		validBooleanWrapper('interface StringMemberWrapper {\'value-state\': boolean} declare const isReady: StringMemberWrapper;', {booleanWrappers: {StringMemberWrapper: 'value-state'}}),
-		validBooleanWrapper('interface PromiseWrapper {get: Promise<boolean>} declare const isReady: PromiseWrapper;', {booleanWrappers: {PromiseWrapper: 'get'}}),
-		validBooleanWrapper('interface PromiseLikeWrapper {get(): PromiseLike<boolean>} declare const isReady: PromiseLikeWrapper;', {booleanWrappers: {PromiseLikeWrapper: 'get'}}),
+		validBooleanWrapper('interface BooleanWrapper {value: boolean} declare const isReady: BooleanWrapper;', {wrappers: {BooleanWrapper: 'value'}}),
+		validBooleanWrapper('interface DirectBooleanMethodWrapper {get(): boolean} declare const isReady: DirectBooleanMethodWrapper;', {wrappers: {DirectBooleanMethodWrapper: 'get'}}),
+		validBooleanWrapper('interface BooleanWrapper {get(): boolean} declare const ready: BooleanWrapper;', {wrappers: {BooleanWrapper: 'get'}}),
+		validBooleanWrapper('interface StringMemberWrapper {\'value-state\': boolean} declare const isReady: StringMemberWrapper;', {wrappers: {StringMemberWrapper: 'value-state'}}),
+		validBooleanWrapper('interface PromiseWrapper {get: Promise<boolean>} declare const isReady: PromiseWrapper;', {wrappers: {PromiseWrapper: 'get'}}),
+		validBooleanWrapper('interface PromiseLikeWrapper {get(): PromiseLike<boolean>} declare const isReady: PromiseLikeWrapper;', {wrappers: {PromiseLikeWrapper: 'get'}}),
 	],
 	invalid: [
 		invalidBooleanWrapper(`${storageItemType} declare const isUnicorn: StorageItem<unknown, string>;`),
@@ -104,17 +104,17 @@ test({
 			'interface ExtendedStorageItem<Return> extends StorageItem<Return> {}',
 			'declare const isUnicorn: ExtendedStorageItem<string>;',
 		].join('\n')),
-		invalidBooleanWrapper('interface MissingMember {value: boolean} declare const isReady: MissingMember;', {booleanWrappers: {MissingMember: 'get'}}),
-		invalidBooleanWrapper('interface StringPropertyWrapper {get: string} declare const isReady: StringPropertyWrapper;', {booleanWrappers: {StringPropertyWrapper: 'get'}}),
+		invalidBooleanWrapper('interface MissingMember {value: boolean} declare const isReady: MissingMember;', {wrappers: {MissingMember: 'get'}}),
+		invalidBooleanWrapper('interface StringPropertyWrapper {get: string} declare const isReady: StringPropertyWrapper;', {wrappers: {StringPropertyWrapper: 'get'}}),
 		invalidBooleanWrapper([
 			'interface OverloadedWrapper {',
 			'\tget(): Promise<boolean>;',
 			'\tget(value: string): Promise<string>;',
 			'}',
 			'declare const isReady: OverloadedWrapper;',
-		].join('\n'), {booleanWrappers: {OverloadedWrapper: 'get'}}),
+		].join('\n'), {wrappers: {OverloadedWrapper: 'get'}}),
 		// Boolean wrappers intentionally apply only to variable and parameter bindings.
-		invalidBooleanWrapper('interface BooleanWrapper {get(): Promise<boolean>} interface Settings {isReady: BooleanWrapper}', {checkProperties: true, booleanWrappers: {BooleanWrapper: 'get'}}),
+		invalidBooleanWrapper('interface BooleanWrapper {get(): Promise<boolean>} interface Settings {isReady: BooleanWrapper}', {checkProperties: true, wrappers: {BooleanWrapper: 'get'}}),
 		invalidBooleanWrapper(`${storageItemType} let isUnicorn: StorageItem<unknown, boolean> = value; isUnicorn = value;`),
 		invalidBooleanWrapper(`${storageItemType} declare const isUnicorn: StorageItem<unknown, boolean>;`, {}),
 		typescript({