Angular 5. Circular dependency in typescript when import classes into each other

You should not edit RadioGroup attributes from Radio. Communication between child and parent components should be done via @Input and @Output.

So remove RadioGroup from Radio constructor. Instead you can do following,

import { 
   Component, 
   Input,
   EventEmitter,
   Output,
   ChangeDetectorRef,
   ChangeDetectionStrategy
} from '@angular/core';

@Component({
  selector: 'radio',
  styles: [`:host{cursor:pointer;}`],
  template: `
     <div (click)='check()'>
        <span *ngIf='!checked'>⚪️</span>
        <span *ngIf='checked'>🔘</span>
        <span>Click me. Value: {{value}} Checked: {{checked}}</span>
     </div>`,
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export class Radio  {
  @Input() value: any;
  @Output() valueChange: EventEmitter<any> = new EventEmitter();
  checked = false;
  constructor(public cd: ChangeDetectorRef){
  }
  check(){
    this.checked = true;
    this.valueChange.emit(this.value);
    this.markForCheck();
  }
  markForCheck(){
    this.cd.markForCheck();
  }
}

RadioGroup.component

@Component({
  selector: 'radio-group',
  template: `<ng-content></ng-content>`,
})
export class RadioGroup implements AfterContentInit, OnChanges, OnDestroy {
  set selected(component: Radio) {
    this._selected = component;
    this.valueChange.emit(component.value);
  }
  private _selected: Radio = null;
  @Input() value: any;
  @Output() valueChange = new EventEmitter();
  @ContentChildren(forwardRef(() => Radio)) radioComponents: QueryList<Radio>;

  subscriptionList = [];

  ngAfterContentInit() { this.checkParentComponents(); }
  ngOnChanges() { this.checkParentComponents(); }
  checkParentComponents(): void {
    if (this.radioComponents) {
      this.subscriptionList = this.radioComponents.map(item => {
        item.checked = item.value === this.value;
        if (item.checked) { this._selected = item; }
        item.markForCheck();
        // subscribe to each child "valueChange" event and return these subscriptions.
        return item.valueChange.subscription(value => this.selected = value);
      });

    }
  }

  ngOnDestroy() {
      // don't forget to unsubscribe.
      if (this.subscriptionList && this.subscriptionList.length ) {
          this.subscriptionList.forEach(sub => sub.unsubscribe());
      }
  }
}

Try in Radio component constructor instead of

constructor(@Optional() radioGroup: RadioGroup, public cd: ChangeDetectorRef)

this code

constructor(@Inject(forwardRef(() => RadioGroup)) radioGroup: RadioGroup, public cd: ChangeDetectorRef)

When you need set up communication between components

And CAN NOT use @Output and @Inputs, use providers. DependencyInjection allow you override injected in constructor class whenever you need it.

DependencyInjection (angular.io)

Avoid circular dependencies(angular.io)

radio-group.component.ts:

import { RadioGroupBase } from './radio-group-base';

@Component({
  selector: 'radio-group',
  ...
  ==> providers: [{provide: RadioGroupBase, useExisting: RadioGroup}]
})
export class RadioGroup implements AfterContentInit, OnChanges{
...
}

radio.component.ts:

import { RadioGroupBase } from './radio-group-base';

@Component({
  selector: 'radio',
  ...
})
export class Radio  {
  constructor(
   ==> @Optional() radioGroup: RadioGroupBase, 
  ){
    //variable radioGroup will be undefined when there is no provider.
  }

radio-group-base.ts:

export class RadioGroupBase {
  selected: any;
}

Working solution:

https://stackblitz.com/edit/angular-gyqmve

Use a shared Service https://angularfirebase.com/lessons/sharing-data-between-angular-components-four-methods/ Section: "Unrelated Components: Sharing Data with a Service"

Angular 2 - Using Shared Service