Use the new inject function about until-destroy HOT 10 CLOSED

@Injectable()
export class BarService {
  destroy$ = untilDestroyed();

  init() {
    interval(1000).pipe(
      this.destroy$
    ).subscribe(console.log)
  }
}

@Component({
  selector: 'app-foo',
  templateUrl: './foo.component.html',
  providers: [
    BarService
  ],
})

@NgModule()
export class SomeModule {
  destroy$ = untilDestroyed(); // No provider for ChangeDetectorRef!
}

@Injectable({ providedIn: 'root' })
export class RootService {
  destroy$ = untilDestroyed(); // No provider for ChangeDetectorRef!
}

@Pipe({ name: 'impure', pure: false })
export class ImpurePipe implements PipeTransform {
  destroy$ = untilDestroyed();

  constructor() {
    new Subject()
      .pipe(
        this.destroy$,
        finalize(() => console.log('Finalized')) // Not called
      )
      .subscribe();
  }

  transform(value: string) {
    return 'Hey';
  }

  ngOnDestroy(): void {
    console.log('Called when `shown` becomes `false`.');
  }
}

@Directive({ selector: '[myDirective]' })
export class MyDirective {
  destroy$ = untilDestroyed();

  constructor() {
    new Subject()
      .pipe(
        this.destroy$,
        finalize(() => console.log('Finalized')) // Not called
      )
      .subscribe();
  }

  ngOnDestroy(): void {
    console.log('Called when `shown` becomes `false`.');
  }
}

@Component({
  selector: 'app-root',
  template: `
    <button (click)="shown = !shown">Toggle</button>
    <ng-template [ngIf]="shown">
      <div myDirective></div>
      {{ "" | impure }}
    </ng-template>
  `
})
export class AppComponent {
  shown = true;
}

const symbol = Symbol('untilDestroyed');
const patched = Symbol('patched');

export function untilDestroyed(instance: any) {
  const proto = Object.getPrototypeOf(instance);

  if (!proto[patched]) {
    proto[patched] = true;
    const original = proto.ngOnDestroy;

    proto.ngOnDestroy = function () {
      original?.apply(this, arguments);
      this[symbol].next();
      this[symbol].complete();
    }
  }

  instance[symbol] = new Subject<void>();

  return takeUntil(instance[symbol].asObservable())
}