@testgorilla/tgo-coding-test 2.0.0 → 2.0.1

package/src/lib/components/coding-question/coding-question.component.ts

@@ -1,101 +0,0 @@
-import {
-  ChangeDetectionStrategy,
-  ChangeDetectorRef,
-  Component,
-  EventEmitter,
-  inject,
-  Input,
-  OnDestroy,
-  OnInit,
-  Output,
-} from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { UntilDestroy, untilDestroyed } from '@ngneat/until-destroy';
-import { map } from 'rxjs';
-import { MatCardModule } from '@angular/material/card';
-import { AngularSplitModule } from 'angular-split';
-import { ApplicationTheme, ButtonComponentModule } from '@testgorilla/tgo-ui';
-import { LATLanguages } from '../../models/lat-languages';
-import { Modes } from '../../models/mode';
-import { ExampleTestCase } from '../../models/test-cases';
-import { Themes } from '../../models/theme';
-import { ConfigurationsService } from '../../services/configurations.service';
-import { LibCodingTestService } from '../../services/lib-coding-test.service';
-import {
-  CodeEditorFuncParam,
-  CodeEditorLanguages,
-  CodeEditorTypesMap,
-} from '../code-editor/helpers/code-editor-helper.model';
-import { PasteData } from '../code-editor/models/code-editor.model';
-import { InstructionsComponent } from '../instructions/instructions.component';
-import { RunnableEditorComponent } from '../runnable-editor/runnable-editor.component';
-
-@UntilDestroy()
-@Component({
-    selector: 'tgo-coding-question',
-    templateUrl: './coding-question.component.html',
-    styleUrls: ['./coding-question.component.scss'],
-    changeDetection: ChangeDetectionStrategy.OnPush,
-    imports: [
-        CommonModule,
-        MatCardModule,
-        AngularSplitModule,
-        ButtonComponentModule,
-        InstructionsComponent,
-        RunnableEditorComponent,
-    ]
-})
-export class CodingQuestionComponent implements OnInit, OnDestroy {
-  private readonly changeDetectorRef = inject(ChangeDetectorRef);
-  private readonly libCodingTestService = inject(LibCodingTestService);
-  private readonly configurationsService = inject(ConfigurationsService);
-  
-  @Input() initCode: string;
-  @Input() functionParams: CodeEditorFuncParam[];
-  @Input() functionName: string;
-  @Input() returnType: keyof CodeEditorTypesMap;
-  @Input() isLAT: boolean;
-  @Input() isSQL: boolean;
-  @Input() canAddCustomTestCases: boolean;
-  @Input() languages: LATLanguages;
-  @Input() autoHeight: boolean;
-  @Input() translations: Record<string, unknown>;
-  @Input() questionText: string;
-  @Input() mode: Modes;
-  @Input() companyColor: string;
-  @Input() testCasesStatus: any;
-  @Input() loading: boolean;
-  @Input() hideTestCases: boolean;
-  @Input() runTestResponse = [];
-  @Input() exampleTestCases: ExampleTestCase[];
-  @Input() applicationTheme: ApplicationTheme;
-
-  @Output() pasteEvent = new EventEmitter<PasteData>();
-  @Output() codeChange = new EventEmitter<string>();
-  @Output() runTestClick = new EventEmitter<boolean>();
-  @Output() languageChange = new EventEmitter<CodeEditorLanguages>();
-
-  isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
-
-  isFullscreenMode: boolean;
-
-  GUTTER_SIZE = 1;
-
-  isDarkTheme$ = this.configurationsService.colorTheme$.pipe(map(theme => theme === Themes.Dark));
-
-  ngOnInit(): void {
-    this.libCodingTestService.isFullscreen$.pipe(untilDestroyed(this)).subscribe(isFullscreen => {
-      this.isFullscreenMode = isFullscreen;
-    });
-  }
-
-  ngOnDestroy(): void {
-    this.configurationsService.setCodeComponentDestroyed(true);
-    this.configurationsService.setColorTheme(Themes.Default);
-    this.configurationsService.closeConfigPanel();
-  }
-
-  enableFullScreenMode(): void {
-    this.libCodingTestService.setFullscreen(true);
-  }
-}

package/src/lib/components/coding-section/coding-section.component.html

@@ -1,82 +0,0 @@
-<section class="section">
-  <header *ngIf="isFullViewMode || isRunnableWithLangSelector" class="section-header">
-    <h2 class="heading">{{ translations['HEADINGS']['CODING'] }}</h2>
-    <div class="header-controls" [class.is-full-screen]="isFullscreenMode$ | async">
-      <form *ngIf="isLAT" [formGroup]="headerForm" class="header-form">
-        <ui-tooltip [message]="languages.length === 1 ? translations['TOOLTIPS']['DISABLE_LANGUAGE'] : null">
-          <ui-dropdown
-            id="language-dropdown"
-            class="language-dropdown"
-            formControlName="language"
-            [valueList]="languagesFormattedList"
-            [showBottomContent]="false"
-            [allowClear]="false"
-            [applicationTheme]="applicationTheme"
-          ></ui-dropdown>
-        </ui-tooltip>
-      </form>
-      <ui-button
-        [variant]="'icon-button'"
-        [iconName]="'Reset'"
-        [tooltip]="translations['TOOLTIPS']['RESET_CODE']"
-        [disabled]="hasNoCodeChanges"
-        [applicationTheme]="applicationTheme"
-        (buttonClickEvent)="resetCode()"
-        class="themed-button"
-      >
-      </ui-button>
-      <ui-button
-        *ngIf="isLAT && !isMobile && !isRunnableWithLangSelector"
-        [variant]="'icon-button'"
-        [iconName]="'Help'"
-        [tooltip]="translations['TOOLTIPS']['HELP']"
-        [applicationTheme]="applicationTheme"
-        (buttonClickEvent)="startGuidedTour()"
-        class="themed-button"
-      >
-      </ui-button>
-      <ui-button
-        *ngIf="!isRunnableWithLangSelector"
-        [variant]="'icon-button'"
-        [iconName]="'Settings'"
-        [tooltip]="translations['TOOLTIPS']['CONFIGURATIONS']"
-        [applicationTheme]="applicationTheme"
-        id="configuration-ide-button"
-        class="themed-button"
-        (buttonClickEvent)="openConfigPanel()"
-      >
-      </ui-button>
-
-      <ui-button
-        *ngIf="(isFullscreenMode$ | async) && !isMobile"
-        [variant]="'icon-button'"
-        [iconName]="'Minimize'"
-        [tooltip]="translations['TOOLTIPS']['MINIMIZE']"
-        [tooltipPosition]="'left'"
-        [applicationTheme]="applicationTheme"
-        class="themed-button"
-        (buttonClickEvent)="disableFullscreen()"
-      >
-      </ui-button>
-    </div>
-  </header>
-
-  <div class="ide" [class.spinner]="isLAT | memoizeFunc: isCodeLoading$ : this | async">
-    <tgo-code-editor
-      *ngIf="(isLAT | memoizeFunc: isCodeLoading$ : this | async) === false; else showSpinner"
-      [initCode]="initCode"
-      [functionParams]="functionParams"
-      [functionName]="functionName"
-      [returnType]="returnType"
-      [shouldGenerateInitCode]="!isFullViewMode && !isRunnableWithLangSelector && shouldGenerateInitCode"
-      [hasCodingConfigPanel]="isFullViewMode"
-      [autoHeight]="autoHeight"
-      (pasteEvent)="pasteEvent.emit($event)"
-      (codeChange)="parseCodeChange($event)"
-    >
-    </tgo-code-editor>
-    <ng-template #showSpinner>
-      <ui-spinner [isLoader]="false" class="code-loading-spinner"></ui-spinner>
-    </ng-template>
-  </div>
-</section>

package/src/lib/components/coding-section/coding-section.component.scss

@@ -1,64 +0,0 @@
-.section {
-  display: flex;
-  flex-direction: column;
-  height: 100%;
-  overflow-y: hidden;
-}
-
-.section-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  padding: 8px 16px;
-  border-bottom: 1px solid #E0E0E0;
-  max-height: 67px;
-
-  .header-controls {
-    display: flex;
-    width: 100%;
-    max-width: 265px;
-    justify-content: flex-end;
-    align-items: center;
-    flex: 1 1 auto;
-
-    .header-form {
-      flex: 1;
-      padding-right: 1em;
-    }
-
-    &.is-full-screen {
-      max-width: 305px;
-    }
-  }
-}
-
-.heading {
-  margin: 0;
-  padding: 10px 8px;
-  flex: 0 0 auto;
-}
-
-.ide {
-  flex: 1 0 auto;
-
-  @media screen and (max-width: 959px) {
-    flex: 1 0 350px;
-  }
-
-  &.spinner {
-    display: flex;
-    align-items: center;
-
-    .code-loading-spinner {
-      margin: 0 auto;
-    }
-  }
-}
-
-.icon {
-  ::ng-deep {
-    svg, path {
-      fill: var(--icon-bg-color);
-    }
-  }
-}

package/src/lib/components/coding-section/coding-section.component.spec.ts

@@ -1,257 +0,0 @@
-import { NO_ERRORS_SCHEMA, SimpleChange, SimpleChanges } from '@angular/core';
-import { ComponentFixture, fakeAsync, TestBed, tick, waitForAsync } from '@angular/core/testing';
-
-import { MockProvider } from 'ng-mocks';
-import { MonacoEditorModule } from 'ngx-monaco-editor-v2';
-import { BehaviorSubject, Subject } from 'rxjs';
-import { MemoizeFuncPipe } from '../../pipes/memoize-func.pipe';
-import { LibCodingTestService } from '../../services/lib-coding-test.service';
-import { CodeEditorLanguages } from '../code-editor/helpers/code-editor-helper.model';
-import { CodingSectionComponent } from './coding-section.component';
-import { ConfigurationsService } from '../../services/configurations.service';
-import { CONFIGURATIONS_SERVICE_MOCK } from '../../services/configurations.service.mocks';
-import { FormBuilder } from '@angular/forms';
-import { StorageCodingService } from '../../services/storage.service';
-import { LanguageChangeAction } from '../../models/language-change-action';
-
-describe('CodingSectionComponent', () => {
-  let component: CodingSectionComponent;
-  let fixture: ComponentFixture<CodingSectionComponent>;
-  let libCodingTestService: LibCodingTestService;
-  let configurationsService: ConfigurationsService;
-  let changeCurrentCodeSpy: jest.SpyInstance;
-  const initCode = 'init code';
-
-  beforeEach(waitForAsync(() => {
-    TestBed.configureTestingModule({
-      imports: [CodingSectionComponent, MonacoEditorModule.forRoot(), MemoizeFuncPipe],
-      schemas: [NO_ERRORS_SCHEMA],
-      providers: [
-        MockProvider(LibCodingTestService, {
-          codeChange$: new Subject(),
-          changeCurrentCode(code: string) {
-            this.codeChange$.next(code);
-          },
-          isBoilerplateLoading$: new Subject(),
-          setBoilerplateLoadingStatus(value: boolean) {
-            this.isBoilerplateLoading$.next(value);
-          },
-          languageChange$: new Subject(),
-          codeReset$: new Subject(),
-          getInitCode: () => initCode,
-          currentLanguage$: new BehaviorSubject<CodeEditorLanguages>(CodeEditorLanguages.Javascript),
-        }),
-        MockProvider(ConfigurationsService, CONFIGURATIONS_SERVICE_MOCK),
-        FormBuilder,
-        MockProvider(StorageCodingService),
-      ],
-    })
-    .overrideComponent(CodingSectionComponent, {
-      set: {
-        template: '',
-      },
-    })
-    .compileComponents();
-  }));
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(CodingSectionComponent);
-    component = fixture.componentInstance;
-    component.translations = {
-      HEADINGS: {},
-      TOOLTIPS: {},
-    };
-    component.languages = [
-      {
-        value: CodeEditorLanguages.Python,
-        label: 'python',
-        version: '1',
-      },
-    ];
-    component.initCode = 'sample python code';
-    libCodingTestService = TestBed.inject(LibCodingTestService);
-    configurationsService = TestBed.inject(ConfigurationsService);
-    changeCurrentCodeSpy = jest.spyOn(libCodingTestService, 'changeCurrentCode');
-
-    fixture.detectChanges();
-  });
-
-  describe('when the component is initialized', () => {
-    describe('and when isLAT is true', () => {
-      beforeEach(() => {
-        component.isLAT = true;
-      });
-
-      it('should initialize header form when isLAT is true', () => {
-        component.ngOnInit();
-
-        expect(component.headerForm).toBeDefined();
-        expect(component.headerForm.get('language')).toBeDefined();
-        expect(component.headerForm.get('language').value).toBe(CodeEditorLanguages.Javascript);
-        expect(component.headerForm.get('language').disabled).toBe(true);
-      });
-
-      it('should NOT disable language control of headerForm', () => {
-        component.languages = [
-          ...component.languages,
-          {
-            value: CodeEditorLanguages.Java,
-            label: 'java',
-          },
-        ];
-
-        component.ngOnInit();
-
-        expect(component.headerForm).toBeDefined();
-        expect(component.headerForm.get('language').enabled).toBe(true);
-      });
-
-      it('should set previousLanguage to languageControl value', () => {
-        component.ngOnInit();
-
-        expect(component.previousLanguage).toBe(CodeEditorLanguages.Javascript);
-      });
-
-      it('should emit languageChange value when language form value is changed', fakeAsync(() => {
-        const languageChangeEmitSpy = jest.spyOn(component.languageChange, 'emit');
-
-        component.ngOnInit();
-        component.language.patchValue(CodeEditorLanguages.Cpp);
-        tick();
-
-        expect(languageChangeEmitSpy).toHaveBeenCalledWith(CodeEditorLanguages.Cpp);
-      }));
-
-      it('should set language control value to previousLang if LanguageChangeAction.Cancel', fakeAsync(() => {
-        component.ngOnInit();
-        component.previousLanguage = CodeEditorLanguages.Php;
-        (libCodingTestService.languageChange$ as Subject<LanguageChangeAction>).next(LanguageChangeAction.Cancel);
-        tick();
-
-        expect(component.language.value).toBe(CodeEditorLanguages.Php);
-      }));
-
-      describe('and when LanguageChangeAction.Confirm is emitted', () => {
-        it('should set prevLanguage to language control value and changeCurrentLanguage is called', fakeAsync(() => {
-          const changeCurrentLanguageSpy = jest.spyOn(libCodingTestService, 'changeCurrentLanguage');
-
-          component.ngOnInit();
-          component.previousLanguage = CodeEditorLanguages.Php;
-          component.language.patchValue(CodeEditorLanguages.Python);
-          (libCodingTestService.languageChange$ as Subject<LanguageChangeAction>).next(LanguageChangeAction.Confirm);
-          tick();
-
-          expect(component.previousLanguage).toBe(CodeEditorLanguages.Python);
-          expect(changeCurrentLanguageSpy).toHaveBeenCalledWith(CodeEditorLanguages.Python);
-        }));
-      });
-    });
-  });
-
-  describe('when initCode changes', () => {
-    it('should call the necessary setters', () => {
-      const codeChangeSpy = jest.spyOn(component.codeChange, 'emit');
-      const oldInitCode = component.initCode;
-      const newInitCode = 'sample java code';
-      component.initCode = newInitCode;
-      const changes: SimpleChanges = {
-        initCode: new SimpleChange(oldInitCode, newInitCode, false),
-      };
-      component.ngOnChanges(changes);
-
-      expect(codeChangeSpy).toBeCalledWith(newInitCode);
-      expect(changeCurrentCodeSpy).toBeCalledWith(newInitCode);
-    });
-  });
-
-  describe('when parseCodeChange is called', () => {
-    it('should emit code change event with new code string', () => {
-      const code = 'new code';
-      const emitSpy = jest.spyOn(component.codeChange, 'emit');
-
-      component.parseCodeChange(code);
-
-      expect(emitSpy).toHaveBeenCalledWith(code);
-      expect(changeCurrentCodeSpy).toHaveBeenCalledWith(code);
-    });
-
-    it('should set hasNoCodeChanges to false if code is different from initial code', () => {
-      const code = 'new code';
-
-      component.parseCodeChange(code);
-
-      expect(component.hasNoCodeChanges).toBe(false);
-    });
-
-    it('should set hasNoCodeChanges to true if code is the same as initial code', () => {
-      const code = initCode;
-
-      component.parseCodeChange(code);
-
-      expect(component.hasNoCodeChanges).toBe(true);
-    });
-  });
-
-  describe('when the code is reset', () => {
-    let resetCodeSpy: jest.SpyInstance;
-
-    beforeEach(() => {
-      resetCodeSpy = jest.spyOn(libCodingTestService, 'resetCode');
-      component.resetCode();
-    });
-
-    it('should call service reset code method', () => {
-      expect(resetCodeSpy).toBeCalled();
-    });
-  });
-
-  describe('when the guided tour is triggered', () => {
-    let startGuidedTourSpy: jest.SpyInstance;
-
-    beforeEach(() => {
-      startGuidedTourSpy = jest.spyOn(libCodingTestService, 'startGuidedTour');
-      component.startGuidedTour();
-    });
-
-    it('should call service reset code method', () => {
-      expect(startGuidedTourSpy).toBeCalled();
-    });
-  });
-
-  describe('when disableFullscreen is called', () => {
-    it('should call setFullscreen method with false', () => {
-      const setFullScreenSpy = jest.spyOn(libCodingTestService, 'setFullscreen');
-      component.disableFullscreen();
-
-      expect(setFullScreenSpy).toHaveBeenCalledWith(false);
-    });
-  });
-
-  describe('when openConfigPanel is called', () => {
-    it('should call openConfigPanel method of ConfigurationsService', () => {
-      const openConfigPanelSpy = jest.spyOn(configurationsService, 'openConfigPanel');
-      component.openConfigPanel();
-
-      expect(openConfigPanelSpy).toHaveBeenCalled();
-    });
-  });
-
-  describe('when isCodeLoading$ is called', () => {
-    it('should return false observable if test is NOT LAT', done => {
-      component.isLAT = false;
-      component.isCodeLoading$(component.isLAT).subscribe(val => {
-        expect(val).toEqual(false);
-        done();
-      });
-    });
-    it('should return boilerplate loading status if test is LAT', done => {
-      component.isLAT = true;
-      const boilerplateLoadingStatus = true;
-      component.isCodeLoading$(component.isLAT).subscribe(val => {
-        expect(val).toEqual(boilerplateLoadingStatus);
-        done();
-      });
-      libCodingTestService.setBoilerplateLoadingStatus(boilerplateLoadingStatus);
-    });
-  });
-});

package/src/lib/components/coding-section/coding-section.component.ts

@@ -1,186 +0,0 @@
-import { ChangeDetectionStrategy, Component, EventEmitter, inject, Input, OnChanges, OnInit, Output, SimpleChanges } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { AbstractControl, FormBuilder, FormGroup, ReactiveFormsModule } from '@angular/forms';
-import { UntilDestroy, untilDestroyed } from '@ngneat/until-destroy';
-import { distinctUntilChanged, Observable, of, take, tap } from 'rxjs';
-import {
-  ApplicationTheme,
-  OptionType,
-  TooltipComponentModule,
-  DropdownComponentModule,
-  ButtonComponentModule,
-  SpinnerComponentModule,
-} from '@testgorilla/tgo-ui';
-
-import { LanguageChangeAction } from '../../models/language-change-action';
-import { LATLanguages } from '../../models/lat-languages';
-import { ConfigurationsService } from '../../services/configurations.service';
-import { LibCodingTestService } from '../../services/lib-coding-test.service';
-import { StorageCodingService } from '../../services/storage.service';
-import {
-  CodeEditorFuncParam,
-  CodeEditorLanguages,
-  CodeEditorTypesMap,
-} from '../code-editor/helpers/code-editor-helper.model';
-import { PasteData } from '../code-editor/models/code-editor.model';
-import { MemoizeFuncPipe } from '../../pipes/memoize-func.pipe';
-import { CodeEditorComponent } from '../code-editor/code-editor.component';
-
-@UntilDestroy()
-@Component({
-    selector: 'tgo-coding-section',
-    templateUrl: './coding-section.component.html',
-    styleUrls: ['./coding-section.component.scss'],
-    changeDetection: ChangeDetectionStrategy.OnPush,
-    imports: [
-        CommonModule,
-        ReactiveFormsModule,
-        TooltipComponentModule,
-        DropdownComponentModule,
-        ButtonComponentModule,
-        SpinnerComponentModule,
-        MemoizeFuncPipe,
-        CodeEditorComponent,
-    ]
-})
-export class CodingSectionComponent implements OnInit, OnChanges {
-  private readonly configurationsService = inject(ConfigurationsService);
-  private readonly libCodingTestService = inject(LibCodingTestService);
-  private readonly StorageCodingService = inject(StorageCodingService);
-  private readonly fb = inject(FormBuilder);
-
-  @Input() initCode: string;
-  @Input() functionParams: CodeEditorFuncParam[];
-  @Input() functionName: string;
-  @Input() returnType: keyof CodeEditorTypesMap;
-  @Input() isLAT = false;
-  @Input() languages: LATLanguages;
-  @Input() isFullViewMode: boolean;
-  @Input() shouldGenerateInitCode: boolean;
-  @Input() isRunnableWithLangSelector: boolean;
-  @Input() autoHeight: boolean;
-  @Input() translations: Record<string, unknown>;
-  @Input() isMobile: boolean;
-  @Input() applicationTheme: ApplicationTheme;
-
-  @Output() pasteEvent = new EventEmitter<PasteData>();
-  @Output() codeChange = new EventEmitter<string>();
-  @Output() languageChange = new EventEmitter<CodeEditorLanguages>();
-
-  headerForm: FormGroup;
-  isFullscreenMode$ = this.libCodingTestService.isFullscreen$;
-  previousLanguage: CodeEditorLanguages;
-  code: string;
-
-  languagesFormattedList: OptionType[];
-
-  ngOnInit() {
-    if (this.isLAT) {
-      this.createHeaderForm().subscribe(() => {
-        this.initializeLanguage();
-        this.listenLanguageDropdownChanges();
-        this.handleLanguageChangeModal();
-      });
-    }
-  }
-
-  ngOnChanges(changes: SimpleChanges): void {
-    if (typeof changes.initCode?.currentValue === 'string') {
-      this.codeChange.emit(changes.initCode.currentValue);
-      this.libCodingTestService.changeCurrentCode(changes.initCode.currentValue);
-    }
-    if (changes.languages?.currentValue) {
-      this.languagesFormattedList = this.languages.map(({ value, label }) => ({
-        value,
-        displayValue: label,
-      }));
-    }
-  }
-
-  private createHeaderForm(): Observable<CodeEditorLanguages> {
-    return this.libCodingTestService.currentLanguage$.pipe(
-      take(1),
-      tap(lastLanguage => {
-        this.headerForm = this.fb.group({
-          language: lastLanguage ? lastLanguage : this.languages[0].value,
-        });
-        if (this.languages.length === 1) {
-          this.language.disable();
-        }
-      })
-    );
-  }
-
-  private initializeLanguage() {
-    this.previousLanguage = this.language.value as CodeEditorLanguages;
-  }
-
-  private listenLanguageDropdownChanges() {
-    this.language.valueChanges
-      .pipe(untilDestroyed(this), distinctUntilChanged())
-      .subscribe((value: CodeEditorLanguages) => {
-        if (value !== this.previousLanguage) {
-          this.languageChange.emit(value);
-        }
-      });
-  }
-
-  private handleLanguageChangeModal() {
-    this.libCodingTestService.languageChange$.pipe(untilDestroyed(this)).subscribe(value => {
-      if (value === LanguageChangeAction.Cancel) {
-        // Revert language to previous selection if user cancels
-        this.language.setValue(this.previousLanguage);
-      } else if (value === LanguageChangeAction.Confirm) {
-        this.previousLanguage = this.language.value as CodeEditorLanguages;
-        // Update current language if user confirms the new selection
-        this.libCodingTestService.changeCurrentLanguage(this.language.value as CodeEditorLanguages);
-        this.setVersion();
-      }
-    });
-  }
-
-  parseCodeChange(code: string): void {
-    this.codeChange.emit(code);
-    this.libCodingTestService.changeCurrentCode(code);
-    this.code = code;
-  }
-
-  get hasNoCodeChanges(): boolean {
-    return this.code === this.libCodingTestService.getInitCode();
-  }
-
-  resetCode(): void {
-    this.libCodingTestService.resetCode();
-  }
-
-  startGuidedTour(): void {
-    this.libCodingTestService.startGuidedTour();
-  }
-
-  disableFullscreen(): void {
-    this.libCodingTestService.setFullscreen(false);
-  }
-
-  openConfigPanel(): void {
-    this.configurationsService.openConfigPanel();
-  }
-
-  isCodeLoading$(isLAT: boolean): Observable<boolean> {
-    if (isLAT) {
-      return this.libCodingTestService.isBoilerplateLoading$;
-    }
-    return of(false);
-  }
-
-  get language(): AbstractControl {
-    return this.headerForm.controls.language;
-  }
-
-  private setVersion() {
-    const version = this.languages.find(x => x.value === this.language.value).version;
-    this.libCodingTestService.setVersion(version);
-    if (this.isFullViewMode) {
-      this.StorageCodingService.updateVersion(version);
-    }
-  }
-}