Fix dependency injection in Angular services

projects/angular-auth-oidc-client/src/lib/interceptor/auth.interceptor.ts

@@ -16,12 +16,15 @@ import { ClosestMatchingRouteService } from './closest-matching-route.service';
 
 @Injectable()
 export class AuthInterceptor implements HttpInterceptor {
-  constructor(
-    private readonly authStateService: AuthStateService,
-    private readonly configurationService: ConfigurationService,
-    private readonly loggerService: LoggerService,
-    private readonly closestMatchingRouteService: ClosestMatchingRouteService
-  ) {}
+  private readonly authStateService = inject(AuthStateService);
+
+  private readonly configurationService = inject(ConfigurationService);
+
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly closestMatchingRouteService = inject(
+    ClosestMatchingRouteService
+  );
 
   intercept(
     req: HttpRequest<any>,

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { Observable, of } from 'rxjs';
 import { AuthOptions } from '../auth-options';
 import { OpenIdConfiguration } from '../config/openid-configuration';
@@ -12,13 +12,17 @@ import { StandardLoginService } from './standard/standard-login.service';
 
 @Injectable({ providedIn: 'root' })
 export class LoginService {
-  constructor(
-    private readonly parLoginService: ParLoginService,
-    private readonly popUpLoginService: PopUpLoginService,
-    private readonly standardLoginService: StandardLoginService,
-    private readonly storagePersistenceService: StoragePersistenceService,
-    private readonly popupService: PopUpService
-  ) {}
+  private readonly parLoginService = inject(ParLoginService);
+
+  private readonly popUpLoginService = inject(PopUpLoginService);
+
+  private readonly standardLoginService = inject(StandardLoginService);
+
+  private readonly storagePersistenceService = inject(
+    StoragePersistenceService
+  );
+
+  private readonly popupService = inject(PopUpService);
 
   login(
     configuration: OpenIdConfiguration | null,

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { Observable, of, throwError } from 'rxjs';
 import { switchMap, take } from 'rxjs/operators';
 import { AuthOptions } from '../../auth-options';
@@ -18,16 +18,23 @@ import { ParService } from './par.service';
 
 @Injectable({ providedIn: 'root' })
 export class ParLoginService {
-  constructor(
-    private readonly loggerService: LoggerService,
-    private readonly responseTypeValidationService: ResponseTypeValidationService,
-    private readonly urlService: UrlService,
-    private readonly redirectService: RedirectService,
-    private readonly authWellKnownService: AuthWellKnownService,
-    private readonly popupService: PopUpService,
-    private readonly checkAuthService: CheckAuthService,
-    private readonly parService: ParService
-  ) {}
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly responseTypeValidationService = inject(
+    ResponseTypeValidationService
+  );
+
+  private readonly urlService = inject(UrlService);
+
+  private readonly redirectService = inject(RedirectService);
+
+  private readonly authWellKnownService = inject(AuthWellKnownService);
+
+  private readonly popupService = inject(PopUpService);
+
+  private readonly checkAuthService = inject(CheckAuthService);
+
+  private readonly parService = inject(ParService);
 
   loginPar(
     configuration: OpenIdConfiguration,

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

@@ -1,5 +1,5 @@
 import { HttpHeaders } from '@angular/common/http';
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { Observable, throwError } from 'rxjs';
 import { catchError, map, retry, switchMap } from 'rxjs/operators';
 import { DataService } from '../../api/data.service';
@@ -12,12 +12,15 @@ import { ParResponse } from './par-response';
 
 @Injectable({ providedIn: 'root' })
 export class ParService {
-  constructor(
-    private readonly loggerService: LoggerService,
-    private readonly urlService: UrlService,
-    private readonly dataService: DataService,
-    private readonly storagePersistenceService: StoragePersistenceService
-  ) {}
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly urlService = inject(UrlService);
+
+  private readonly dataService = inject(DataService);
+
+  private readonly storagePersistenceService = inject(
+    StoragePersistenceService
+  );
 
   postParRequest(
     configuration: OpenIdConfiguration,

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { Observable, of, throwError } from 'rxjs';
 import { switchMap, take, tap } from 'rxjs/operators';
 import { AuthOptions } from '../../auth-options';
@@ -15,14 +15,19 @@ import { PopUpService } from './popup.service';
 
 @Injectable({ providedIn: 'root' })
 export class PopUpLoginService {
-  constructor(
-    private readonly loggerService: LoggerService,
-    private readonly responseTypeValidationService: ResponseTypeValidationService,
-    private readonly urlService: UrlService,
-    private readonly authWellKnownService: AuthWellKnownService,
-    private readonly popupService: PopUpService,
-    private readonly checkAuthService: CheckAuthService
-  ) {}
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly responseTypeValidationService = inject(
+    ResponseTypeValidationService
+  );
+
+  private readonly urlService = inject(UrlService);
+
+  private readonly authWellKnownService = inject(AuthWellKnownService);
+
+  private readonly popupService = inject(PopUpService);
+
+  private readonly checkAuthService = inject(CheckAuthService);
 
   loginWithPopUpStandard(
     configuration: OpenIdConfiguration,

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

@@ -1,5 +1,5 @@
 import { DOCUMENT } from '@angular/common';
-import { Inject, Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { Observable, Subject } from 'rxjs';
 import { OpenIdConfiguration } from '../../config/openid-configuration';
 import { LoggerService } from '../../logging/logger.service';
@@ -9,6 +9,14 @@ import { PopupResult } from './popup-result';
 
 @Injectable({ providedIn: 'root' })
 export class PopUpService {
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly storagePersistenceService = inject(
+    StoragePersistenceService
+  );
+
+  private readonly document = inject(DOCUMENT);
+
   private readonly STORAGE_IDENTIFIER = 'popupauth';
 
   private popUp: Window | null = null;
@@ -25,12 +33,6 @@ export class PopUpService {
     return this.document.defaultView;
   }
 
-  constructor(
-    @Inject(DOCUMENT) private readonly document: Document,
-    private readonly loggerService: LoggerService,
-    private readonly storagePersistenceService: StoragePersistenceService
-  ) {}
-
   isCurrentlyInPopup(config: OpenIdConfiguration): boolean {
     if (this.canAccessSessionStorage()) {
       const popup = this.storagePersistenceService.read(

projects/angular-auth-oidc-client/src/lib/login/response-type-validation/response-type-validation.service.ts

@@ -1,14 +1,13 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { OpenIdConfiguration } from '../../config/openid-configuration';
 import { LoggerService } from '../../logging/logger.service';
 import { FlowHelper } from '../../utils/flowHelper/flow-helper.service';
 
 @Injectable({ providedIn: 'root' })
 export class ResponseTypeValidationService {
-  constructor(
-    private readonly loggerService: LoggerService,
-    private readonly flowHelper: FlowHelper
-  ) {}
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly flowHelper = inject(FlowHelper);
 
   hasConfigValidResponseType(configuration: OpenIdConfiguration): boolean {
     if (this.flowHelper.isCurrentFlowAnyImplicitFlow(configuration)) {

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { AuthOptions } from '../../auth-options';
 import { AuthWellKnownService } from '../../config/auth-well-known/auth-well-known.service';
 import { OpenIdConfiguration } from '../../config/openid-configuration';
@@ -10,14 +10,19 @@ import { ResponseTypeValidationService } from '../response-type-validation/respo
 
 @Injectable({ providedIn: 'root' })
 export class StandardLoginService {
-  constructor(
-    private readonly loggerService: LoggerService,
-    private readonly responseTypeValidationService: ResponseTypeValidationService,
-    private readonly urlService: UrlService,
-    private readonly redirectService: RedirectService,
-    private readonly authWellKnownService: AuthWellKnownService,
-    private readonly flowsDataService: FlowsDataService
-  ) {}
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly responseTypeValidationService = inject(
+    ResponseTypeValidationService
+  );
+
+  private readonly urlService = inject(UrlService);
+
+  private readonly redirectService = inject(RedirectService);
+
+  private readonly authWellKnownService = inject(AuthWellKnownService);
+
+  private readonly flowsDataService = inject(FlowsDataService);
 
   loginStandard(
     configuration: OpenIdConfiguration,

projects/angular-auth-oidc-client/src/lib/logoff-revoke/logoff-revocation.service.ts

@@ -1,5 +1,5 @@
 import { HttpHeaders } from '@angular/common/http';
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { Observable, of, throwError } from 'rxjs';
 import { catchError, concatMap, retry, switchMap } from 'rxjs/operators';
 import { DataService } from '../api/data.service';
@@ -15,15 +15,21 @@ import { UrlService } from '../utils/url/url.service';
 
 @Injectable({ providedIn: 'root' })
 export class LogoffRevocationService {
-  constructor(
-    private readonly dataService: DataService,
-    private readonly storagePersistenceService: StoragePersistenceService,
-    private readonly loggerService: LoggerService,
-    private readonly urlService: UrlService,
-    private readonly checkSessionService: CheckSessionService,
-    private readonly resetAuthDataService: ResetAuthDataService,
-    private readonly redirectService: RedirectService
-  ) {}
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly dataService = inject(DataService);
+
+  private readonly storagePersistenceService = inject(
+    StoragePersistenceService
+  );
+
+  private readonly urlService = inject(UrlService);
+
+  private readonly checkSessionService = inject(CheckSessionService);
+
+  private readonly resetAuthDataService = inject(ResetAuthDataService);
+
+  private readonly redirectService = inject(RedirectService);
 
   // Logs out on the server and the local client.
   // If the server state has changed, check session, then only a local logout.

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

@@ -1,14 +1,13 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { OpenIdConfiguration } from '../config/openid-configuration';
 import { LoggerService } from '../logging/logger.service';
 import { AbstractSecurityStorage } from './abstract-security-storage';
 
 @Injectable({ providedIn: 'root' })
 export class BrowserStorageService {
-  constructor(
-    private readonly loggerService: LoggerService,
-    private readonly abstractSecurityStorage: AbstractSecurityStorage
-  ) {}
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly abstractSecurityStorage = inject(AbstractSecurityStorage);
 
   read(key: string, configuration: OpenIdConfiguration): any {
     const { configId } = configuration;

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 import { BehaviorSubject, Observable, of, throwError } from 'rxjs';
 import { map, retry, switchMap } from 'rxjs/operators';
 import { DataService } from '../api/data.service';
@@ -23,14 +23,19 @@ export class UserService {
     return this.userDataInternal$.asObservable();
   }
 
-  constructor(
-    private readonly oidcDataService: DataService,
-    private readonly storagePersistenceService: StoragePersistenceService,
-    private readonly eventService: PublicEventsService,
-    private readonly loggerService: LoggerService,
-    private readonly tokenHelperService: TokenHelperService,
-    private readonly flowHelper: FlowHelper
-  ) {}
+  private readonly loggerService = inject(LoggerService);
+
+  private readonly tokenHelperService = inject(TokenHelperService);
+
+  private readonly flowHelper = inject(FlowHelper);
+
+  private readonly oidcDataService = inject(DataService);
+
+  private readonly storagePersistenceService = inject(
+    StoragePersistenceService
+  );
+
+  private readonly eventService = inject(PublicEventsService);
 
   getAndPersistUserDataInStore(
     currentConfiguration: OpenIdConfiguration,

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

@@ -1,14 +1,15 @@
 import { DOCUMENT } from '@angular/common';
-import { Inject, Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 
 @Injectable({ providedIn: 'root' })
 export class CryptoService {
-  constructor(@Inject(DOCUMENT) private readonly doc: Document) {}
+  private readonly document = inject<Document>(DOCUMENT);
 
   getCrypto(): any {
     // support for IE,  (window.crypto || window.msCrypto)
     return (
-      this.doc.defaultView?.crypto || (this.doc.defaultView as any)?.msCrypto
+      this.document.defaultView?.crypto ||
+      (this.document.defaultView as any)?.msCrypto
     );
   }
 }

projects/angular-auth-oidc-client/src/lib/utils/platform-provider/platform.provider.ts

@@ -1,11 +1,11 @@
 import { isPlatformBrowser } from '@angular/common';
-import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { Injectable, PLATFORM_ID, inject } from '@angular/core';
 
 @Injectable({ providedIn: 'root' })
 export class PlatformProvider {
+  private readonly platformId = inject<string>(PLATFORM_ID);
+
   isBrowser(): boolean {
     return isPlatformBrowser(this.platformId);
   }
-
-  constructor(@Inject(PLATFORM_ID) private readonly platformId: string) {}
 }

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

@@ -1,9 +1,9 @@
 import { DOCUMENT } from '@angular/common';
-import { Inject, Injectable } from '@angular/core';
+import { Injectable, inject } from '@angular/core';
 
 @Injectable({ providedIn: 'root' })
 export class RedirectService {
-  constructor(@Inject(DOCUMENT) private readonly document: Document) {}
+  private readonly document = inject<Document>(DOCUMENT);
 
   redirectTo(url: string): void {
     this.document.location.href = url;