Oct 23, 2024 · Oct 17, 2024 · Oct 17, 2024 · Oct 17, 2024 · Oct 21, 2024 · Oct 21, 2024
diff --git a/packages/eslint-plugin/docs/rules/consistent-indexed-object-style.mdx b/packages/eslint-plugin/docs/rules/consistent-indexed-object-style.mdx
 >
 > See **https://typescript-eslint.io/rules/consistent-indexed-object-style** for documentation.

 TypeScript supports defining arbitrary object keys using an index signature. TypeScript also has a builtin type named `Record` to create an empty object defining only an index signature. For example, the following types are equal:
 TypeScript supports defining arbitrary object keys using an index signature or mapped type.
 TypeScript also has a builtin type named `Record` to create an empty object defining only an index signature.
 For example, the following types are equal:

 ```ts
 interfaceFoo {
 interfaceIndexSignatureInterface {
  [key: string]: unknown;
 }

 typeFoo = {
 typeIndexSignatureType = {
  [key: string]: unknown;
 };

 type Foo = Record<string, unknown>;
 type MappedType = {
  [key in string]: unknown;
 };

 type RecordType = Record<string, unknown>;
 ```

 Using one declaration form consistently improves code readability.
 <TabItem value="❌ Incorrect">

 ```ts option='"record"'
 interfaceFoo {
 interfaceIndexSignatureInterface {
  [key: string]: unknown;
 }

 typeFoo = {
 typeIndexSignatureType = {
  [key: string]: unknown;
 };

 type MappedType = {
  [key in string]: unknown;
 };
 ```

 </TabItem>
 <TabItem value="✅ Correct">

 ```ts option='"record"'
 typeFoo = Record<string, unknown>;
 typeRecordType = Record<string, unknown>;
 ```

 </TabItem>
 <TabItem value="❌ Incorrect">

 ```ts option='"index-signature"'
 typeFoo = Record<string, unknown>;
 typeRecordType = Record<string, unknown>;
 ```

 </TabItem>
 <TabItem value="✅ Correct">

 ```ts option='"index-signature"'
 interfaceFoo {
 interfaceIndexSignatureInterface {
  [key: string]: unknown;
 }

 typeFoo = {
 typeIndexSignatureType = {
  [key: string]: unknown;
 };

 type MappedType = {
  [key in string]: unknown;
 };
 ```

 </TabItem>
diff --git a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import type { ReportFixFunction } from '@typescript-eslint/utils/ts-eslint';

 import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';

 import { createRule } from '../util';
 import { createRule, isParenthesized, nullThrows } from '../util';

 type MessageIds = 'preferIndexSignature' | 'preferRecord';
 type Options = ['index-signature' | 'record'];
            !node.extends.length,
          );
        },
        TSMappedType(node): void {
          const key = node.key;
          const scope = context.sourceCode.getScope(key);

          const scopeManagerKey = nullThrows(
            scope.variables.find(
              value => value.name === key.name && value.isTypeVariable,
            ),
            'key type parameter must be a defined type variable in its scope',
          );

          // If the key is used to compute the value, we can't convert to a Record.
          if (
            scopeManagerKey.references.some(
              reference => reference.isTypeReference,
            )
          ) {
            return;
          }

          const constraint = node.constraint;

          if (
            constraint.type === AST_NODE_TYPES.TSTypeOperator &&
            constraint.operator === 'keyof' &&
            !isParenthesized(constraint, context.sourceCode)
          ) {
            // This is a weird special case, since modifiers are preserved by
            // the mapped type, but not by the Record type. So this type is not,
            // in general, equivalent to a Record type.
            return;
          }

          // There's no builtin Mutable<T> type, so we can't autofix it really.
          const canFix = node.readonly !== '-';

          context.report({
            node,
            messageId: 'preferRecord',
            ...(canFix && {
              fix: (fixer): ReturnType<ReportFixFunction> => {
                const keyType = context.sourceCode.getText(constraint);
                const valueType = context.sourceCode.getText(
                  node.typeAnnotation,
                );

                let recordText = `Record<${keyType}, ${valueType}>`;

                if (node.optional === '+' || node.optional === true) {
                  recordText = `Partial<${recordText}>`;
                } else if (node.optional === '-') {
                  recordText = `Required<${recordText}>`;
                }

                if (node.readonly === '+' || node.readonly === true) {
                  recordText = `Readonly<${recordText}>`;
                }

                return fixer.replaceText(node, recordText);
              },
            }),
          });
        },
        TSTypeLiteral(node): void {
          const parent = findParentDeclaration(node);
          checkMembers(node.members, node, parent?.id, '', '');
diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
  tester,
 }));
 type Options = [
  { [Type in (typeof optionTesters)[number]['option']]?: boolean } & {
  {
    allow?: TypeOrValueSpecifier[];
  },
  } & Partial<Record<(typeof optionTesters)[number]['option'], boolean>>,
 ];

 type MessageId = 'invalidType';
diff --git a/packages/eslint-plugin/src/rules/typedef.ts b/packages/eslint-plugin/src/rules/typedef.ts
  VariableDeclarationIgnoreFunction = 'variableDeclarationIgnoreFunction',
 }

 type Options ={ [k inOptionKeys]?: boolean };
 type Options =Partial<Record<OptionKeys, boolean>>;

 type MessageIds = 'expectedTypedef' | 'expectedTypedefNamed';

diff --git a/packages/eslint-plugin/src/util/types.ts b/packages/eslint-plugin/src/util/types.ts
 export type MakeRequired<Base, Key extends keyof Base> = {
  [K in Key]-?: NonNullable<Base[Key]>;
 } & Omit<Base, Key>;
 export type MakeRequired<Base, Key extends keyof Base> = Omit<Base, Key> &
  Required<Record<Key, NonNullable<Base[Key]>>>;

 export type ValueOf<T> = T[keyof T];
diff --git a/...ges/eslint-plugin/tests/docs-eslint-output-snapshots/consistent-indexed-object-style.shot b/...ges/eslint-plugin/tests/docs-eslint-output-snapshots/consistent-indexed-object-style.shot
Original file line number	Diff line number	Diff line change
Expand Up		@@ -9,18 +9,24 @@ import TabItem from '@theme/TabItem';
		>
		> See https://typescript-eslint.io/rules/consistent-indexed-object-style for documentation.

		TypeScript supports defining arbitrary object keys using an index signature. TypeScript also has a builtin type named `Record` to create an empty object defining only an index signature. For example, the following types are equal:
		TypeScript supports defining arbitrary object keys using an index signature or mapped type.
		TypeScript also has a builtin type named `Record` to create an empty object defining only an index signature.
		For example, the following types are equal:
Copy link Member JoshuaKGoldbergOct 21, 2024 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [Praise] 😄 I like the`.\n` splitting Copy link MemberAuthor kirkwaiblingerOct 21, 2024 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Did it just for you 😁 JoshuaKGoldberg reacted with laugh emojiJoshuaKGoldberg reacted with heart emoji

		```ts
		interfaceFoo {
		interfaceIndexSignatureInterface {
		[key: string]: unknown;
		}

		typeFoo = {
		typeIndexSignatureType = {
		[key: string]: unknown;
		};

		type Foo = Record<string, unknown>;
		type MappedType = {
		[key in string]: unknown;
		};

		type RecordType = Record<string, unknown>;
		```

		Using one declaration form consistently improves code readability.
Expand All		@@ -38,20 +44,24 @@ Using one declaration form consistently improves code readability.
		<TabItem value="❌ Incorrect">

		```ts option='"record"'
		interfaceFoo {
		interfaceIndexSignatureInterface {
		[key: string]: unknown;
		}

		typeFoo = {
		typeIndexSignatureType = {
		[key: string]: unknown;
		};

		type MappedType = {
		[key in string]: unknown;
		};
		```

		</TabItem>
		<TabItem value="✅ Correct">

		```ts option='"record"'
		typeFoo = Record<string, unknown>;
		typeRecordType = Record<string, unknown>;
		```

		</TabItem>
Expand All		@@ -63,20 +73,24 @@ type Foo = Record<string, unknown>;
		<TabItem value="❌ Incorrect">

		```ts option='"index-signature"'
		typeFoo = Record<string, unknown>;
		typeRecordType = Record<string, unknown>;
		```

		</TabItem>
		<TabItem value="✅ Correct">

		```ts option='"index-signature"'
		interfaceFoo {
		interfaceIndexSignatureInterface {
		[key: string]: unknown;
		}

		typeFoo = {
		typeIndexSignatureType = {
		[key: string]: unknown;
		};

		type MappedType = {
		[key in string]: unknown;
		};
		```

		</TabItem>
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,8 +1,9 @@
		import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
		import type { ReportFixFunction } from '@typescript-eslint/utils/ts-eslint';

		import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';

		import { createRule } from '../util';
		import { createRule, isParenthesized, nullThrows } from '../util';

		type MessageIds = 'preferIndexSignature' \| 'preferRecord';
		type Options = ['index-signature' \| 'record'];
Expand DownExpand Up		@@ -142,6 +143,69 @@ export default createRule<Options, MessageIds>({
		!node.extends.length,
		);
		},
		TSMappedType(node): void {
		const key = node.key;
		const scope = context.sourceCode.getScope(key);

		const scopeManagerKey = nullThrows(
		scope.variables.find(
		value => value.name === key.name && value.isTypeVariable,
		),
		'key type parameter must be a defined type variable in its scope',
		);

		// If the key is used to compute the value, we can't convert to a Record.
		if (
		scopeManagerKey.references.some(
		reference => reference.isTypeReference,
		)
		) {
		return;
		}

		const constraint = node.constraint;

		if (
		constraint.type === AST_NODE_TYPES.TSTypeOperator &&
		constraint.operator === 'keyof' &&
		!isParenthesized(constraint, context.sourceCode)
		) {
		// This is a weird special case, since modifiers are preserved by
		// the mapped type, but not by the Record type. So this type is not,
		// in general, equivalent to a Record type.
		return;
		}

		// There's no builtin Mutable<T> type, so we can't autofix it really.
		const canFix = node.readonly !== '-';

		context.report({
		node,
		messageId: 'preferRecord',
		...(canFix && {
		fix: (fixer): ReturnType<ReportFixFunction> => {
		const keyType = context.sourceCode.getText(constraint);
		const valueType = context.sourceCode.getText(
		node.typeAnnotation,
		);

		let recordText = `Record<${keyType}, ${valueType}>`;

		if (node.optional === '+' \|\| node.optional === true) {
		recordText = `Partial<${recordText}>`;
		} else if (node.optional === '-') {
		recordText = `Required<${recordText}>`;
kirkwaiblinger marked this conversation as resolved. Show resolvedHide resolved
		}

		if (node.readonly === '+' \|\| node.readonly === true) {
		recordText = `Readonly<${recordText}>`;
		}

		return fixer.replaceText(node, recordText);
		},
		}),
		});
		},
		TSTypeLiteral(node): void {
		const parent = findParentDeclaration(node);
		checkMembers(node.members, node, parent?.id, '', '');
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -57,9 +57,9 @@ const optionTesters = (
		tester,
		}));
		type Options = [
		{ [Type in (typeof optionTesters)[number]['option']]?: boolean } & {
		{
		allow?: TypeOrValueSpecifier[];
		},
		} & Partial<Record<(typeof optionTesters)[number]['option'], boolean>>,
		];

		type MessageId = 'invalidType';
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -15,7 +15,7 @@ const enum OptionKeys {
		VariableDeclarationIgnoreFunction = 'variableDeclarationIgnoreFunction',
		}

		type Options ={ [k inOptionKeys]?: boolean };
		type Options =Partial<Record<OptionKeys, boolean>>;

		type MessageIds = 'expectedTypedef' \| 'expectedTypedefNamed';

Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,5 +1,4 @@
		export type MakeRequired<Base, Key extends keyof Base> = {
		[K in Key]-?: NonNullable<Base[Key]>;
		} & Omit<Base, Key>;
		export type MakeRequired<Base, Key extends keyof Base> = Omit<Base, Key> &
		Required<Record<Key, NonNullable<Base[Key]>>>;

		export type ValueOf<T> = T[keyof T];