@igniteui/angular-templates 21.1.1491 → 21.1.1500-rc.0

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/providers/providers.spec.ts

@@ -1,305 +0,0 @@
-import { FacebookProvider } from './facebook-provider';
-import { GoogleProvider } from './google-provider';
-import { MicrosoftProvider } from './microsoft-provider';
-
-describe('Providers', () => {
-  const MOCK_EXTERNAL_AUTH_CONFIG = {
-    stsServer: 'test-stsServer',
-    redirect_url: 'test-redirect_url',
-    client_id: 'test-client_id',
-    response_type: 'test-response_type',
-    scope: 'test-scope',
-    post_login_route: 'test-post_login_route',
-    auto_userinfo: 'test-auto_userinfo',
-    max_id_token_iat_offset_allowed_in_seconds: 'test-max_id_token_iat_offset_allowed_in_seconds'
-  } as any;
-  const MOCK_ROUTER = {
-    navigate: () => { }
-  } as any;
-  const MOCK_OIDC_CONFIG = {
-    wellKnownEndpoints: {
-      issuer: ''
-    },
-    load_using_stsServer: () => { },
-    onConfigurationLoaded: {
-      pipe: () => { }
-    }
-  } as any;
-  const MOCK_OIDC_SECURITY = {
-    setupModule: () => { },
-    authorize: () => { },
-    getToken: () => { },
-    onAuthorizationResult: () => { },
-    authorizedImplicitFlowCallback: () => { },
-    getUserData: () => { },
-    logoff: () => { }
-  } as any;
-  describe('Facebook Provider', () => {
-    const facebookProviderName = 'FB';
-    let mockResponse: any = {};
-    let mockAPIObj = {
-      id: 'mock-id',
-      name: 'mock-name',
-      first_name: 'mock-first_name',
-      last_name: 'mock_last_name',
-      email: 'mock_email',
-      picture: 'mock_picture'
-    };
-    global[facebookProviderName] = {
-      login: (callback: (obj: any) => void, scope: { scope: string }) => { callback({ authResponse: mockResponse }); },
-      init: () => { },
-      api: (params: string, callback: (obj: any) => void) => { callback(mockAPIObj); },
-      getAuthResponse: (): any => { return { accessToken: 'mockAccessToken' } },
-      logout: () => { },
-      AppEvents: null,
-      Canvas: null,
-      Event: null,
-      getLoginStatus: (): any => null,
-      ui: (params: any, callback: (response: any) => void): void => { },
-      XFBML: null
-    };
-    it('Should properly initialize', () => {
-      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
-      expect(provider).toBeDefined();
-    });
-
-    it('Should properly call config', () => {
-      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
-      spyOn(FB, 'init');
-      provider.config();
-      expect(FB.init).toHaveBeenCalled();
-      expect(FB.init).toHaveBeenCalledWith({
-        appId: MOCK_EXTERNAL_AUTH_CONFIG.client_id,
-        xfbml: false,
-        version: 'v3.1'
-      });
-    });
-
-    it('Should properly call login', () => {
-      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
-      spyOn(provider, 'config');
-      spyOn(FB, 'login').and.callThrough();
-      spyOn(console, 'log').and.callThrough();
-      spyOn(FB, 'api').and.callThrough();
-      mockResponse = false;
-      provider.login();
-      expect(provider.config).toHaveBeenCalledTimes(1);
-      expect(FB.login).toHaveBeenCalledTimes(1);
-      expect(FB.api).not.toHaveBeenCalled();
-      expect(console.log).toHaveBeenCalledWith('User cancelled login or did not fully authorize.');
-      spyOn(FB, 'getAuthResponse').and.returnValue({ accessToken: 'Fake' } as any);
-      spyOn(MOCK_ROUTER, 'navigate');
-      mockResponse = true;
-      const mockObj = {
-        id: 'test id',
-        name: 'test name',
-        first_name: 'test first name',
-        last_name: 'test family name',
-        email: 'test email',
-        picture: 'test picture'
-      };
-      const expectedObject = {
-        id: 'test id',
-        name: 'test name',
-        given_name: 'test first name',
-        family_name: 'test family name',
-        email: 'test email',
-        picture: 'test picture',
-        externalToken: 'Fake'
-      };
-      mockAPIObj = mockObj;
-      provider.login();
-      expect(provider.config).toHaveBeenCalledTimes(2);
-      expect(FB.login).toHaveBeenCalledTimes(2);
-      expect(FB.api).toHaveBeenCalled();
-      expect(MOCK_ROUTER.navigate).toHaveBeenCalledWith([MOCK_EXTERNAL_AUTH_CONFIG.redirect_url]);
-      expect((provider as any).user).toEqual(expectedObject);
-    });
-
-    it(`Should properly call 'getUserInfo'`, () => {
-      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
-      provider.login();
-      spyOn(Promise, 'resolve').and.returnValue('Mock' as any);
-      expect(provider.getUserInfo()).toEqual('Mock' as any);
-    });
-
-    it(`Should properly call 'logout'`, () => {
-      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
-      spyOn(FB, 'logout');
-      provider.logout();
-      expect(FB.logout).toHaveBeenCalled();
-    });
-  });
-
-  describe('Google Provider', () => {
-
-    it('Should properly initialize', () => {
-      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      expect(provider).toBeDefined();
-    });
-
-    it('Should properly call config', () => {
-      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      spyOn(MOCK_OIDC_SECURITY, 'setupModule').and.callThrough();
-      provider.config();
-      expect(MOCK_OIDC_SECURITY.setupModule).toHaveBeenCalled();
-    });
-
-    it('Should properly call login', () => {
-      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      const mockSub = {
-        subscribe: (fn: () => {}) => {
-          fn.apply(MOCK_OIDC_SECURITY);
-        }
-      };
-      spyOn(mockSub, 'subscribe').and.callThrough();
-      spyOn(MOCK_OIDC_SECURITY, 'authorize');
-      spyOn(MOCK_OIDC_CONFIG.onConfigurationLoaded, 'pipe').and.returnValue(mockSub);
-      spyOn(MOCK_OIDC_CONFIG, 'load_using_stsServer');
-      const mockSpy = spyOn(provider, 'config');
-      provider.login();
-      expect(mockSub.subscribe).toHaveBeenCalled();
-      expect(mockSpy).toHaveBeenCalled();
-      expect(MOCK_OIDC_SECURITY.authorize).toHaveBeenCalled();
-      expect(MOCK_OIDC_CONFIG.load_using_stsServer).toHaveBeenCalled();
-    });
-
-    it(`Should properly call 'formatUserData'`, () => {
-      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      const mockObj = {
-        sub: 'test-id',
-        name: 'test-name',
-        email: 'test-email',
-        given_name: 'test-given_name',
-        family_name: 'test-family_name',
-        picture: 'test-picture'
-      };
-      spyOn(MOCK_OIDC_SECURITY, 'getToken').and.returnValue('FAKE');
-      expect((provider as any).formatUserData(mockObj)).toEqual({
-        id: mockObj.sub,
-        name: mockObj.name,
-        email: mockObj.email,
-        given_name: mockObj.given_name,
-        family_name: mockObj.family_name,
-        picture: mockObj.picture,
-        externalToken: 'FAKE'
-      });
-    });
-
-    it('Should properly call getUserInfo', () => {
-      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      const mockSub = {
-        subscribe: (fn: () => {}) => {
-          fn.apply(this);
-        }
-      };
-      spyOn(mockSub, 'subscribe').and.callThrough();
-      spyOn(MOCK_OIDC_CONFIG.onConfigurationLoaded, 'pipe').and.returnValue(mockSub);
-      spyOn(provider, 'config');
-      spyOn(MOCK_OIDC_CONFIG, 'load_using_stsServer');
-      MOCK_OIDC_SECURITY.onAuthorizationResult = mockSub;
-      spyOn(MOCK_OIDC_SECURITY, 'getUserData').and.returnValue(mockSub);
-      spyOn(MOCK_OIDC_SECURITY, 'authorizedImplicitFlowCallback');
-      const formatDataSpy = spyOn<any>(provider, 'formatUserData');
-      provider.getUserInfo();
-      expect(mockSub.subscribe).toHaveBeenCalled();
-      expect(mockSub.subscribe).toHaveBeenCalledTimes(3);
-      expect(formatDataSpy).toHaveBeenCalled();
-      expect(provider.config).toHaveBeenCalled();
-      expect(MOCK_OIDC_SECURITY.authorizedImplicitFlowCallback).toHaveBeenCalled();
-      expect(MOCK_OIDC_CONFIG.load_using_stsServer).toHaveBeenCalled();
-    });
-
-    it('Should properly call logout', () => {
-      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      spyOn(MOCK_OIDC_SECURITY, 'logoff').and.callThrough();
-      provider.logout();
-      expect(MOCK_OIDC_SECURITY.logoff).toHaveBeenCalled();
-    });
-  });
-
-  describe('Microsoft Provider', () => {
-
-    it('Should properly initialize', () => {
-      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      expect(provider).toBeDefined();
-    });
-
-    it('Should properly call config', () => {
-      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      spyOn(MOCK_OIDC_SECURITY, 'setupModule').and.callThrough();
-      provider.config();
-      expect(MOCK_OIDC_SECURITY.setupModule).toHaveBeenCalled();
-    });
-
-    it('Should properly call config if tenant !== consumer', () => {
-      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      provider.tenant = 'test';
-      provider.tenantID = 'test_id';
-      const replaceSpy = spyOn<any>(String.prototype, 'replace');
-      spyOn(MOCK_OIDC_SECURITY, 'setupModule').and.callThrough();
-      provider.config();
-      expect(replaceSpy).toHaveBeenCalledWith('{tenantid}', 'test_id');
-      expect(MOCK_OIDC_SECURITY.setupModule).toHaveBeenCalled();
-    });
-
-    it('Should properly call login', () => {
-      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      const mockSub = {
-        subscribe: (fn: () => {}) => {
-          fn.apply(MOCK_OIDC_SECURITY);
-        }
-      };
-      spyOn(mockSub, 'subscribe').and.callThrough();
-      spyOn(MOCK_OIDC_SECURITY, 'authorize');
-      spyOn(MOCK_OIDC_CONFIG.onConfigurationLoaded, 'pipe').and.returnValue(mockSub);
-      spyOn(MOCK_OIDC_CONFIG, 'load_using_stsServer');
-      const mockSpy = spyOn(provider, 'config');
-      provider.login();
-      expect(mockSub.subscribe).toHaveBeenCalled();
-      expect(mockSpy).toHaveBeenCalled();
-      expect(MOCK_OIDC_SECURITY.authorize).toHaveBeenCalled();
-      expect(MOCK_OIDC_CONFIG.load_using_stsServer).toHaveBeenCalled();
-    });
-
-    it('Should properly call getUserInfo', () => {
-      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      const mockSub = {
-        subscribe: (fn: () => {}) => {
-          fn.apply(MOCK_OIDC_SECURITY);
-        }
-      };
-      spyOn(mockSub, 'subscribe').and.callThrough();
-      spyOn(MOCK_OIDC_CONFIG.onConfigurationLoaded, 'pipe').and.returnValue(mockSub);
-      spyOn(MOCK_OIDC_CONFIG, 'load_using_stsServer');
-      spyOn(provider, 'config');
-      spyOn(MOCK_OIDC_SECURITY, 'authorizedImplicitFlowCallback');
-      MOCK_OIDC_SECURITY.onAuthorizationResult = mockSub;
-      spyOn(MOCK_OIDC_SECURITY, 'getUserData').and.returnValue(mockSub);
-      const formatDataSpy = spyOn<any>(provider, 'formatUserData');
-      provider.getUserInfo();
-      expect(mockSub.subscribe).toHaveBeenCalled();
-      expect(mockSub.subscribe).toHaveBeenCalledTimes(3);
-      expect(formatDataSpy).toHaveBeenCalled();
-      expect(provider.config).toHaveBeenCalled();
-      expect(MOCK_OIDC_SECURITY.authorizedImplicitFlowCallback).toHaveBeenCalled();
-      expect(MOCK_OIDC_CONFIG.load_using_stsServer).toHaveBeenCalled();
-    });
-
-    it(`Should properly call 'formatUserData'`, () => {
-      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
-      const mockObj = {
-        oid: 'test-id',
-        name: 'test-name',
-        email: 'test-email',
-      };
-      spyOn(MOCK_OIDC_SECURITY, 'getToken').and.returnValue('FAKE');
-      expect((provider as any).formatUserData(mockObj)).toEqual({
-        id: mockObj.oid,
-        name: mockObj.name,
-        email: mockObj.email,
-        externalToken: 'FAKE'
-      });
-    });
-  });
-});

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/redirect/redirect.component.spec.ts

@@ -1,60 +0,0 @@
-import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
-import { ActivatedRoute, Router } from '@angular/router';
-import { RouterTestingModule } from '@angular/router/testing';
-import { AuthenticationService } from '../services/authentication.service';
-import { ExternalAuthService } from '../services/external-auth.service';
-import { UserService } from '../services/user.service';
-import { RedirectComponent } from './redirect.component';
-
-describe('RedirectComponent', () => {
-  let fixture: ComponentFixture<RedirectComponent>;
-  const activeRouteSpy: any = { snapshot: { data: { value: { provider: {} } } } };
-  const extAuthSpy = jasmine.createSpyObj('ExternalAuthService', ['getUserInfo']);
-  const authSpy = jasmine.createSpyObj('AuthenticationService', ['loginWith']);
-  const userServSpy = jasmine.createSpyObj('UserService', ['setCurrentUser']);
-
-  beforeEach(waitForAsync(() => {
-    TestBed.configureTestingModule({
-      imports: [RouterTestingModule],
-      declarations: [RedirectComponent],
-      providers: [
-        { provide: ActivatedRoute, useValue: activeRouteSpy },
-        { provide: ExternalAuthService, useValue: extAuthSpy },
-        { provide: AuthenticationService, useValue: authSpy },
-        { provide: UserService, useValue: userServSpy }
-      ]
-    })
-      .compileComponents();
-  }));
-
-  it('should try external login on init', async () => {
-    const router: Router = TestBed.inject(Router);
-    spyOn(router, 'navigate');
-    extAuthSpy.getUserInfo.and.returnValue(Promise.resolve({ test: '1' }));
-    authSpy.loginWith.and.returnValue(Promise.resolve({
-      error: null,
-      user: { name: 'TEST' }
-    }));
-    fixture = TestBed.createComponent(RedirectComponent);
-    fixture.detectChanges();
-    await fixture.whenStable();
-    expect(extAuthSpy.getUserInfo).toHaveBeenCalled();
-    expect(authSpy.loginWith).toHaveBeenCalledWith({ test: '1' });
-    expect(userServSpy.setCurrentUser).toHaveBeenCalledWith({ name: 'TEST' });
-    expect(router.navigate).toHaveBeenCalledWith(['/profile']);
-  });
-
-  it('should show err on external login', async () => {
-    const router: Router = TestBed.inject(Router);
-    spyOn(router, 'navigate');
-    extAuthSpy.getUserInfo.and.returnValue(Promise.resolve({ test: '1' }));
-    authSpy.loginWith.and.returnValue(Promise.resolve({
-      error: 'Err'
-    }));
-    spyOn(window, 'alert');
-    fixture = TestBed.createComponent(RedirectComponent);
-    fixture.detectChanges();
-    await fixture.whenStable();
-    expect(window.alert).toHaveBeenCalledWith('Err');
-  });
-});

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/redirect/redirect.component.ts

@@ -1,36 +0,0 @@
-import { Component, OnInit } from '@angular/core';
-import { ActivatedRoute, Router } from '@angular/router';
-import { ExternalLogin } from '../models/login';
-import { AuthenticationService } from '../services/authentication.service';
-import { ExternalAuthProvider } from '../services/external-auth-configs';
-import { ExternalAuthService } from '../services/external-auth.service';
-import { UserService } from '../services/user.service';
-
-const routeData = 'value';
-
-@Component({
-  template: '<p>Signing in...</p>'
-})
-export class RedirectComponent implements OnInit {
-  private provider: ExternalAuthProvider;
-
-  constructor(
-    route: ActivatedRoute,
-    private router: Router,
-    private user: UserService,
-    private authService: AuthenticationService,
-    private externalAuthService: ExternalAuthService) {
-    this.provider = route.snapshot.data[routeData].provider as ExternalAuthProvider;
-  }
-
-  async ngOnInit() {
-    const userInfo: ExternalLogin = await this.externalAuthService.getUserInfo(this.provider);
-    const result = await this.authService.loginWith(userInfo);
-    if (!result.error) {
-      this.user.setCurrentUser(result.user!);
-      this.router.navigate(['/profile']);
-    } else {
-      alert(result.error);
-    }
-  }
-}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/register/register.component.spec.ts

@@ -1,92 +0,0 @@
-import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
-import { ReactiveFormsModule } from '@angular/forms';
-import { NoopAnimationsModule } from '@angular/platform-browser/animations';
-import { Router } from '@angular/router';
-import { RouterTestingModule } from '@angular/router/testing';
-import { IgxButtonModule, IgxIconModule, IgxInputGroupModule, IgxRippleModule } from 'igniteui-angular';
-import { AuthenticationService } from '../services/authentication.service';
-import { UserService } from '../services/user.service';
-import { RegisterComponent } from './register.component';
-
-const MAIL_GROUP_NAME = 'email';
-const PASSWORD_GROUP_NAME = 'password';
-const USERNAME_GROUP_NAME = 'given_name';
-const FAMILY_NAME_GROUP_NAME = 'family_name';
-
-describe('RegisterComponent', () => {
-  let component: RegisterComponent;
-  let fixture: ComponentFixture<RegisterComponent>;
-  const authSpy = jasmine.createSpyObj('AuthenticationService', ['register']);
-  const userServSpy = jasmine.createSpyObj('UserService', ['setCurrentUser']);
-  const routerSpy = jasmine.createSpyObj('Router', ['navigate']);
-
-  beforeEach(waitForAsync(() => {
-    TestBed.configureTestingModule({
-      imports: [
-        NoopAnimationsModule,
-        ReactiveFormsModule,
-        RouterTestingModule,
-        IgxButtonModule,
-        IgxIconModule,
-        IgxInputGroupModule,
-        IgxRippleModule
-      ],
-      declarations: [RegisterComponent],
-      providers: [
-        { provide: AuthenticationService, useValue: authSpy },
-        { provide: UserService, useValue: userServSpy },
-        { provide: Router, useValue: routerSpy }
-      ]
-    })
-      .compileComponents();
-  }));
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(RegisterComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-
-  it('should submit login data', async () => {
-    expect(component.registrationForm.valid).toBeFalsy();
-    component.registrationForm.controls[USERNAME_GROUP_NAME].setValue('John');
-    expect(component.registrationForm.valid).toBeFalsy();
-    component.registrationForm.controls[MAIL_GROUP_NAME].setValue('test@example.com');
-    expect(component.registrationForm.valid).toBeFalsy();
-    component.registrationForm.controls[PASSWORD_GROUP_NAME].setValue('123456');
-    expect(component.registrationForm.valid).toBeTruthy();
-    component.registrationForm.controls[FAMILY_NAME_GROUP_NAME].setValue('Doe');
-    spyOn(component.registered, 'emit');
-    authSpy.register.and.returnValue(Promise.resolve({
-      error: null,
-      user: { name: 'John Doe' }
-    }));
-    await component.tryRegister();
-    expect(authSpy.register).toHaveBeenCalledTimes(1);
-    expect(authSpy.register).toHaveBeenCalledWith({
-      given_name: 'John',
-      family_name: 'Doe',
-      email: 'test@example.com',
-      password: '123456'
-    });
-    expect(userServSpy.setCurrentUser).toHaveBeenCalledWith({ name: 'John Doe' });
-    expect(component.registered.emit).toHaveBeenCalled();
-    expect(routerSpy.navigate).toHaveBeenCalledWith(['/profile']);
-    authSpy.register.and.returnValue(Promise.resolve({
-      error: 'Reg error'
-    }));
-    spyOn(window, 'alert');
-    await component.tryRegister();
-    expect(window.alert).toHaveBeenCalledWith('Reg error');
-  });
-
-  it(`should properly emit when 'showLoginForm' is called`, () => {
-    spyOn(component.viewChange, 'emit');
-    component.showLoginForm();
-    expect(component.viewChange.emit).toHaveBeenCalled();
-  });
-});

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/register/register.component.ts

@@ -1,48 +0,0 @@
-import { Component, EventEmitter, Output } from '@angular/core';
-import { FormBuilder, FormGroup, Validators } from '@angular/forms';
-import { Router } from '@angular/router';
-import { Register } from '../models/register';
-import { AuthenticationService } from '../services/authentication.service';
-import { UserService } from '../services/user.service';
-
-@Component({
-  selector: 'app-register',
-  templateUrl: './register.component.html',
-  styleUrls: ['./register.component.scss']
-})
-export class RegisterComponent {
-
-  public registrationForm: FormGroup;
-
-  @Output()
-  viewChange: EventEmitter<any> = new EventEmitter();
-  @Output()
-  registered: EventEmitter<any> = new EventEmitter();
-
-  constructor(private authentication: AuthenticationService,
-    private fb: FormBuilder,
-    private userService: UserService,
-    private router: Router) {
-    this.registrationForm = this.fb.group({
-      given_name: ['', Validators.required],
-      family_name: ['', Validators.nullValidator],
-      email: ['', Validators.required],
-      password: ['', Validators.required]
-    });
-  }
-
-  async tryRegister() {
-    const response = await this.authentication.register(this.registrationForm.value as Register);
-    if (!response.error) {
-      this.userService.setCurrentUser(response.user!);
-      this.router.navigate(['/profile']);
-      this.registered.emit();
-    } else {
-      alert(response.error);
-    }
-  }
-
-  showLoginForm() {
-    this.viewChange.emit();
-  }
-}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/services/authentication.service.ts

@@ -1,42 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { Injectable } from '@angular/core';
-import { ExternalLogin, Login } from '../models/login';
-import { Register } from '../models/register';
-import { LoginResult, User } from '../models/user';
-import { parseUser } from './jwt-util';
-
-/** Authentication API Service */
-@Injectable({
-  providedIn: 'root'
-})
-export class AuthenticationService {
-
-  constructor(private http: HttpClient) { }
-
-  /** Send basic credentials to login endpoint. */
-  public async login(userData: Login): Promise<LoginResult> {
-    return this.loginPost('/login', userData);
-  }
-
-  /** Send user info from 3rd party provider to external login endpoint. */
-  public async loginWith(userInfo: ExternalLogin): Promise<LoginResult> {
-    return this.loginPost('/extlogin', userInfo);
-  }
-
-  /** Send user info to register endpoint. */
-  public async register(userData: Register): Promise<LoginResult> {
-    return this.loginPost('/register', userData);
-  }
-
-  protected async loginPost(endpoint: string, userData: any): Promise<LoginResult> {
-    let user: User;
-    try {
-      const data = await this.http.post(endpoint, userData).toPromise() as string;
-      user = parseUser(data);
-    } catch (e: any) {
-      return { error: e.message };
-    }
-
-    return { user };
-  }
-}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/services/external-auth-configs.ts

@@ -1,18 +0,0 @@
-export enum ExternalAuthProvider {
-  Facebook = 'Facebook',
-  Google = 'Google',
-  Microsoft = 'Microsoft'
-}
-
-export interface ExternalAuthConfig {
-  stsServer: string;
-  client_id: string;
-  scope: string;
-  provider: ExternalAuthProvider;
-  redirect_url: string;
-  response_type: string;
-  post_logout_redirect_uri: string;
-  post_login_route: string;
-  auto_userinfo: boolean;
-  max_id_token_iat_offset_allowed_in_seconds: number;
-}