Fix dependency injection issues in logger and service classes

projects/angular-auth-oidc-client/src/lib/auth-state/auth-state.service.ts

@@ -18,6 +18,16 @@ const DEFAULT_AUTHRESULT = {
 
 @Injectable({ providedIn: 'root' })
 export class AuthStateService {
+  private readonly storagePersistenceService = inject(
+    StoragePersistenceService
+  );
+
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly publicEventsService = inject(PublicEventsService);
+
+  private readonly tokenValidationService = inject(TokenValidationService);
+
   private readonly authenticatedInternal$ =
     new BehaviorSubject<AuthenticatedResult>(DEFAULT_AUTHRESULT);
 
@@ -27,13 +37,6 @@ export class AuthStateService {
       .pipe(distinctUntilChanged());
   }
 
-  constructor(
-    private readonly storagePersistenceService: StoragePersistenceService,
-    private readonly loggerService: LoggerService,
-    private readonly publicEventsService: PublicEventsService,
-    private readonly tokenValidationService: TokenValidationService
-  ) {}
-
   setAuthenticatedAndFireEvent(allConfigs: OpenIdConfiguration[]): void {
     const result = this.composeAuthenticatedResult(allConfigs);
 

projects/angular-auth-oidc-client/src/lib/auth-state/check-auth.service.ts

@@ -20,21 +20,35 @@ import { AuthStateService } from './auth-state.service';
 
 @Injectable({ providedIn: 'root' })
 export class CheckAuthService {
-  constructor(
-    private readonly checkSessionService: CheckSessionService,
-    private readonly currentUrlService: CurrentUrlService,
-    private readonly silentRenewService: SilentRenewService,
-    private readonly userService: UserService,
-    private readonly loggerService: LoggerService,
-    private readonly authStateService: AuthStateService,
-    private readonly callbackService: CallbackService,
-    private readonly refreshSessionService: RefreshSessionService,
-    private readonly periodicallyTokenCheckService: PeriodicallyTokenCheckService,
-    private readonly popupService: PopUpService,
-    private readonly autoLoginService: AutoLoginService,
-    private readonly storagePersistenceService: StoragePersistenceService,
-    private readonly publicEventsService: PublicEventsService
-  ) {}
+  private readonly checkSessionService = inject(CheckSessionService);
+
+  private readonly currentUrlService = inject(CurrentUrlService);
+
+  private readonly silentRenewService = inject(SilentRenewService);
+
+  private readonly userService = inject(UserService);
+
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly authStateService = inject(AuthStateService);
+
+  private readonly callbackService = inject(CallbackService);
+
+  private readonly refreshSessionService = inject(RefreshSessionService);
+
+  private readonly periodicallyTokenCheckService = inject(
+    PeriodicallyTokenCheckService
+  );
+
+  private readonly popupService = inject(PopUpService);
+
+  private readonly autoLoginService = inject(AutoLoginService);
+
+  private readonly storagePersistenceService = inject(
+    StoragePersistenceService
+  );
+
+  private readonly publicEventsService = inject(PublicEventsService);
 
   private getConfig(
     configuration: OpenIdConfiguration,

projects/angular-auth-oidc-client/src/lib/callback/refresh-session.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@angular/core';
+import { inject, Injectable } from '@angular/core';
 import {
   forkJoin,
   Observable,
@@ -33,18 +33,31 @@ export const MAX_RETRY_ATTEMPTS = 3;
 
 @Injectable({ providedIn: 'root' })
 export class RefreshSessionService {
-  constructor(
-    private readonly flowHelper: FlowHelper,
-    private readonly flowsDataService: FlowsDataService,
-    private readonly loggerService: LoggerService,
-    private readonly silentRenewService: SilentRenewService,
-    private readonly authStateService: AuthStateService,
-    private readonly authWellKnownService: AuthWellKnownService,
-    private readonly refreshSessionIframeService: RefreshSessionIframeService,
-    private readonly storagePersistenceService: StoragePersistenceService,
-    private readonly refreshSessionRefreshTokenService: RefreshSessionRefreshTokenService,
-    private readonly userService: UserService
-  ) {}
+  private readonly flowHelper = inject(FlowHelper);
+
+  private readonly flowsDataService = inject(FlowsDataService);
+
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly silentRenewService = inject(SilentRenewService);
+
+  private readonly authStateService = inject(AuthStateService);
+
+  private readonly authWellKnownService = inject(AuthWellKnownService);
+
+  private readonly refreshSessionIframeService = inject(
+    RefreshSessionIframeService
+  );
+
+  private readonly storagePersistenceService = inject(
+    StoragePersistenceService
+  );
+
+  private readonly refreshSessionRefreshTokenService = inject(
+    RefreshSessionRefreshTokenService
+  );
+
+  private readonly userService = inject(UserService);
 
   userForceRefreshSession(
     config: OpenIdConfiguration | null,

projects/angular-auth-oidc-client/src/lib/iframe/check-session.service.ts

@@ -1,5 +1,5 @@
 import { DOCUMENT } from '@angular/common';
-import { Inject, Injectable, NgZone, OnDestroy } from '@angular/core';
+import { Injectable, NgZone, OnDestroy, inject } from '@angular/core';
 import { BehaviorSubject, Observable, of } from 'rxjs';
 import { take } from 'rxjs/operators';
 import { OpenIdConfiguration } from '../config/openid-configuration';
@@ -15,6 +15,20 @@ const IFRAME_FOR_CHECK_SESSION_IDENTIFIER = 'myiFrameForCheckSession';
 
 @Injectable({ providedIn: 'root' })
 export class CheckSessionService implements OnDestroy {
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly storagePersistenceService = inject(
+    StoragePersistenceService
+  );
+
+  private readonly iFrameService = inject(IFrameService);
+
+  private readonly eventService = inject(PublicEventsService);
+
+  private readonly zone = inject(NgZone);
+
+  private readonly document = inject(DOCUMENT);
+
   private checkSessionReceived = false;
 
   private scheduledHeartBeatRunning: any;
@@ -37,15 +51,6 @@ export class CheckSessionService implements OnDestroy {
     return this.checkSessionChangedInternal$.asObservable();
   }
 
-  constructor(
-    private readonly storagePersistenceService: StoragePersistenceService,
-    private readonly loggerService: LoggerService,
-    private readonly iFrameService: IFrameService,
-    private readonly eventService: PublicEventsService,
-    private readonly zone: NgZone,
-    @Inject(DOCUMENT) private readonly document: Document
-  ) {}
-
   ngOnDestroy(): void {
     this.stop();
     const windowAsDefaultView = this.document.defaultView;

projects/angular-auth-oidc-client/src/lib/iframe/existing-iframe.service.ts

@@ -1,14 +1,13 @@
 import { DOCUMENT } from '@angular/common';
-import { Inject, Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { OpenIdConfiguration } from '../config/openid-configuration';
 import { LoggerService } from '../logging/logger.service';
 
 @Injectable({ providedIn: 'root' })
 export class IFrameService {
-  constructor(
-    @Inject(DOCUMENT) private readonly document: Document,
-    private readonly loggerService: LoggerService
-  ) {}
+  private readonly document = inject(DOCUMENT);
+
+  private readonly loggerService = inject(LoggerService);
 
   getExistingIFrame(identifier: string): HTMLIFrameElement | null {
     const iFrameOnParent = this.getIFrameFromParentWindow(identifier);

projects/angular-auth-oidc-client/src/lib/iframe/silent-renew.service.ts

@@ -1,5 +1,5 @@
 import { HttpParams } from '@angular/common/http';
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { Observable, Subject, throwError } from 'rxjs';
 import { catchError } from 'rxjs/operators';
 import { AuthStateService } from '../auth-state/auth-state.service';
@@ -26,17 +26,25 @@ export class SilentRenewService {
     return this.refreshSessionWithIFrameCompletedInternal$.asObservable();
   }
 
-  constructor(
-    private readonly iFrameService: IFrameService,
-    private readonly flowsService: FlowsService,
-    private readonly resetAuthDataService: ResetAuthDataService,
-    private readonly flowsDataService: FlowsDataService,
-    private readonly authStateService: AuthStateService,
-    private readonly loggerService: LoggerService,
-    private readonly flowHelper: FlowHelper,
-    private readonly implicitFlowCallbackService: ImplicitFlowCallbackService,
-    private readonly intervalService: IntervalService
-  ) {}
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly iFrameService = inject(IFrameService);
+
+  private readonly flowsService = inject(FlowsService);
+
+  private readonly resetAuthDataService = inject(ResetAuthDataService);
+
+  private readonly flowsDataService = inject(FlowsDataService);
+
+  private readonly authStateService = inject(AuthStateService);
+
+  private readonly flowHelper = inject(FlowHelper);
+
+  private readonly implicitFlowCallbackService = inject(
+    ImplicitFlowCallbackService
+  );
+
+  private readonly intervalService = inject(IntervalService);
 
   getOrCreateIframe(config: OpenIdConfiguration): HTMLIFrameElement {
     const existingIframe = this.getExistingIframe();

projects/angular-auth-oidc-client/src/lib/logging/logger.service.ts

@@ -1,11 +1,11 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { OpenIdConfiguration } from '../config/openid-configuration';
 import { AbstractLoggerService } from './abstract-logger.service';
 import { LogLevel } from './log-level';
 
 @Injectable({ providedIn: 'root' })
 export class LoggerService {
-  constructor(private readonly abstractLoggerService: AbstractLoggerService) {}
+  private readonly abstractLoggerService = inject(AbstractLoggerService);
 
   logError(
     configuration: OpenIdConfiguration,

projects/angular-auth-oidc-client/src/lib/oidc.security.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { Observable } from 'rxjs';
 import { concatMap, map } from 'rxjs/operators';
 import { AuthOptions, LogoutAuthOptions } from './auth-options';
@@ -25,6 +25,32 @@ import { UrlService } from './utils/url/url.service';
 
 @Injectable({ providedIn: 'root' })
 export class OidcSecurityService {
+  private readonly checkSessionService = inject(CheckSessionService);
+
+  private readonly checkAuthService = inject(CheckAuthService);
+
+  private readonly userService = inject(UserService);
+
+  private readonly tokenHelperService = inject(TokenHelperService);
+
+  private readonly configurationService = inject(ConfigurationService);
+
+  private readonly authStateService = inject(AuthStateService);
+
+  private readonly flowsDataService = inject(FlowsDataService);
+
+  private readonly callbackService = inject(CallbackService);
+
+  private readonly logoffRevocationService = inject(LogoffRevocationService);
+
+  private readonly loginService = inject(LoginService);
+
+  private readonly refreshSessionService = inject(RefreshSessionService);
+
+  private readonly urlService = inject(UrlService);
+
+  private readonly authWellKnownService = inject(AuthWellKnownService);
+
   /**
    * Provides information about the user after they have logged in.
    *
@@ -63,22 +89,6 @@ export class OidcSecurityService {
     return this.callbackService.stsCallback$;
   }
 
-  constructor(
-    private readonly checkSessionService: CheckSessionService,
-    private readonly checkAuthService: CheckAuthService,
-    private readonly userService: UserService,
-    private readonly tokenHelperService: TokenHelperService,
-    private readonly configurationService: ConfigurationService,
-    private readonly authStateService: AuthStateService,
-    private readonly flowsDataService: FlowsDataService,
-    private readonly callbackService: CallbackService,
-    private readonly logoffRevocationService: LogoffRevocationService,
-    private readonly loginService: LoginService,
-    private readonly refreshSessionService: RefreshSessionService,
-    private readonly urlService: UrlService,
-    private readonly authWellKnownService: AuthWellKnownService
-  ) {}
-
   preloadAuthWellKnownDocument(
     configId?: string
   ): Observable<AuthWellKnownEndpoints> {