chore: re-write GUI to typescript part 3

lib/gui/app.ts

@@ -1,38 +1,52 @@
-'use strict';
+import {Response} from 'express';
+import _ from 'lodash';
 
-const _ = require('lodash');
-const {ToolRunner} = require('./tool-runner');
+import {ToolRunner, ToolRunnerTree, UndoAcceptImagesResult} from './tool-runner';
+import {HtmlReporterApi} from '../types';
+import Hermione, {Config} from 'hermione';
+import {GuiConfigs} from './index';
+import {TestSpec} from './tool-runner/runner/runner';
+import {TestBranch, TestEqualDiffsData, TestRefUpdateData} from '../tests-tree-builder/gui';
 
-module.exports = class App {
-    static create(paths, hermione, configs) {
-        return new this(paths, hermione, configs);
-    }
+type BrowserConfig = ReturnType<Config['forBrowser']>;
+
+type AppArgs = [paths: string[], hermione: Hermione & HtmlReporterApi, configs: GuiConfigs];
 
-    constructor(paths, hermione, configs) {
-        const {pluginConfig} = configs;
+export class App {
+    private _toolRunner: ToolRunner;
+    private _browserConfigs: BrowserConfig[];
+    private _retryCache: Record<string, number>;
 
+    static create<T extends App>(this: new (...args: AppArgs) => T, ...args: AppArgs): T {
+        return new this(...args);
+    }
+
+    constructor(...[paths, hermione, configs]: AppArgs) {
         this._toolRunner = ToolRunner.create(paths, hermione, configs);
-        this._pluginConfig = pluginConfig;
 
         this._browserConfigs = [];
         this._retryCache = {};
     }
 
-    async initialize() {
+    get data(): ToolRunnerTree | null {
+        return this._toolRunner.tree;
+    }
+
+    async initialize(): Promise<void> {
         return await this._toolRunner.initialize();
     }
 
-    finalize() {
-        this._toolRunner.finalize();
+    async finalize(): Promise<void> {
+        return this._toolRunner.finalize();
     }
 
-    run(tests) {
+    async run(tests: TestSpec[]): Promise<boolean> {
         return _.isEmpty(tests)
             ? this._toolRunner.run()
             : this._runWithoutRetries(tests);
     }
 
-    _runWithoutRetries(tests) {
+    private async _runWithoutRetries(tests: TestSpec[]): Promise<boolean> {
         if (_.isEmpty(this._browserConfigs)) {
             this._browserConfigs = _.map(this._toolRunner.config.getBrowserIds(), (id) => this._toolRunner.config.forBrowser(id));
         }
@@ -43,44 +57,40 @@ module.exports = class App {
             .finally(() => this._restoreRetries());
     }
 
-    getTestsDataToUpdateRefs(imageIds = []) {
+    getTestsDataToUpdateRefs(imageIds: string[] = []): TestRefUpdateData[] {
         return this._toolRunner.getTestsDataToUpdateRefs(imageIds);
     }
 
-    getImageDataToFindEqualDiffs(imageIds = []) {
+    getImageDataToFindEqualDiffs(imageIds: string[] = []): TestEqualDiffsData[] {
         return this._toolRunner.getImageDataToFindEqualDiffs(imageIds);
     }
 
-    updateReferenceImage(failedTests = []) {
+    async updateReferenceImage(failedTests: TestRefUpdateData[] = []): Promise<TestBranch[]> {
         return this._toolRunner.updateReferenceImage(failedTests);
     }
 
-    undoAcceptImages(imageIds) {
+    async undoAcceptImages(imageIds: TestRefUpdateData[]): Promise<UndoAcceptImagesResult> {
         return this._toolRunner.undoAcceptImages(imageIds);
     }
 
-    async findEqualDiffs(data) {
+    async findEqualDiffs(data: TestEqualDiffsData[]): Promise<string[]> {
         return this._toolRunner.findEqualDiffs(data);
     }
 
-    addClient(connection) {
+    addClient(connection: Response): void {
         this._toolRunner.addClient(connection);
     }
 
-    get data() {
-        return this._toolRunner.tree;
-    }
-
-    _disableRetries() {
+    private _disableRetries(): void {
         this._browserConfigs.forEach((broConfig) => {
             this._retryCache[broConfig.id] = broConfig.retry;
             broConfig.retry = 0;
         });
     }
 
-    _restoreRetries() {
+    private _restoreRetries(): void {
         this._browserConfigs.forEach((broConfig) => {
             broConfig.retry = this._retryCache[broConfig.id];
         });
     }
-};
+}

lib/gui/server.js

@@ -7,7 +7,7 @@ const Promise = require('bluebird');
 const bodyParser = require('body-parser');
 const {INTERNAL_SERVER_ERROR, OK} = require('http-codes');
 
-const App = require('./app');
+const {App} = require('./app');
 const {MAX_REQUEST_SIZE, KEEP_ALIVE_TIMEOUT, HEADERS_TIMEOUT} = require('./constants');
 const {initializeCustomGui, runCustomGuiAction} = require('../server-utils');
 const {logger} = require('../common-utils');

lib/gui/tool-runner/index.ts

@@ -36,7 +36,7 @@ import {ImagesInfoFormatter} from '../../image-handler';
 
 type ToolRunnerArgs = [paths: string[], hermione: Hermione & HtmlReporterApi, configs: GuiConfigs];
 
-type ToolRunnerTree = GuiReportBuilderResult & Pick<GuiCliOptions, 'autoRun'>;
+export type ToolRunnerTree = GuiReportBuilderResult & Pick<GuiCliOptions, 'autoRun'>;
 
 interface HermioneTestExtended extends HermioneTest {
     assertViewResults: {stateName: string, refImg: ImageData, currImg: ImageData};