May 12, 2025 · May 5, 2025 · May 5, 2025 · May 5, 2025 · May 5, 2025 · May 5, 2025
diff --git a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
            const scope = context.sourceCode.getScope(key);
            const superVar = ASTUtils.findVariable(scope, parentId.name);
            if (superVar) {
              const isCircular = superVar.references.some(
                item =>
                  item.isTypeReference &&
                  node.range[0] <= item.identifier.range[0] &&
                  node.range[1] >= item.identifier.range[1],
              const isCircular = isDeeplyReferencingType(
                node.parent,
                superVar,
                new Set([parentId]),
              );
              if (isCircular) {
                return;
      return [node.indexType, node.objectType].some(type =>
        isDeeplyReferencingType(type, superVar, visited),
      );
    case AST_NODE_TYPES.TSMappedType:
      if (node.typeAnnotation) {
        return isDeeplyReferencingType(node.typeAnnotation, superVar, visited);
      }

      break;
    case AST_NODE_TYPES.TSConditionalType:
      return [
        node.checkType,
diff --git a/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts b/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts
  [key: string]: ExampleRoot;
 }
    `,
    `
 type Bar<K extends string = never> = {
  [k in K]: Bar;
 };
    `,
    `
 type Bar<K extends string = never> = {
  [k in K]: Foo;
 };

 type Foo = Bar;
    `,

    // Type literal
    'type Foo = {};',
 type Foo3 = Record<string, Record<string, Foo1>>;
      `,
    },
    {
      code: `
 type Foos<K extends string = never> = {
  [k in K]: { foo: Foo };
 };

 type Foo = Foos;
      `,
      errors: [{ column: 39, line: 2, messageId: 'preferRecord' }],
      output: `
 type Foos<K extends string = never> = Record<K, { foo: Foo }>;

 type Foo = Foos;
      `,
    },
    {
      code: `
 type Foos<K extends string = never> = {
  [k in K]: Foo[];
 };

 type Foo = Foos;
      `,
      errors: [{ column: 39, line: 2, messageId: 'preferRecord' }],
      output: `
 type Foos<K extends string = never> = Record<K, Foo[]>;

 type Foo = Foos;
      `,
    },

    // Generic
    {
Original file line number	Diff line number	Diff line change
Expand Up		@@ -205,11 +205,10 @@ export default createRule<Options, MessageIds>({
		const scope = context.sourceCode.getScope(key);
		const superVar = ASTUtils.findVariable(scope, parentId.name);
		if (superVar) {
		const isCircular = superVar.references.some(
		item =>
		item.isTypeReference &&
		node.range[0] <= item.identifier.range[0] &&
		node.range[1] >= item.identifier.range[1],
		const isCircular = isDeeplyReferencingType(
		node.parent,
		superVar,
		new Set([parentId]),
		);
		if (isCircular) {
		return;
Expand DownExpand Up		@@ -291,6 +290,12 @@ function isDeeplyReferencingType(
		return [node.indexType, node.objectType].some(type =>
		isDeeplyReferencingType(type, superVar, visited),
		);
		case AST_NODE_TYPES.TSMappedType:
		if (node.typeAnnotation) {
		return isDeeplyReferencingType(node.typeAnnotation, superVar, visited);
		}

		break;
		case AST_NODE_TYPES.TSConditionalType:
		return [
		node.checkType,
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -174,6 +174,18 @@ interface ExampleObject {
		[key: string]: ExampleRoot;
		}
		`,
		`
		type Bar<K extends string = never> = {
		[k in K]: Bar;
		};
		`,
		`
		type Bar<K extends string = never> = {
		[k in K]: Foo;
		};

		type Foo = Bar;
		`,

		// Type literal
		'type Foo = {};',
Expand DownExpand Up		@@ -646,6 +658,36 @@ type Foo2 = Record<string, Foo3>;
		type Foo3 = Record<string, Record<string, Foo1>>;
		`,
		},
		{
		code: `
		type Foos<K extends string = never> = {
		[k in K]: { foo: Foo };
		};

		type Foo = Foos;
		`,
		errors: [{ column: 39, line: 2, messageId: 'preferRecord' }],
		output: `
		type Foos<K extends string = never> = Record<K, { foo: Foo }>;

		type Foo = Foos;
		`,
		},
		{
		code: `
		type Foos<K extends string = never> = {
		[k in K]: Foo[];
		};

		type Foo = Foos;
		`,
		errors: [{ column: 39, line: 2, messageId: 'preferRecord' }],
		output: `
		type Foos<K extends string = never> = Record<K, Foo[]>;

		type Foo = Foos;
		`,
		},

		// Generic
		{
Expand Down