@pinnacle0/webpack-util 0.3.25 → 0.3.26

package/config/jest.config.ts

@@ -0,0 +1,35 @@
+import type {Config} from "@jest/types";
+
+const config: Config.InitialOptionsWithRootDir = {
+    // Stop running tests after `n` failures
+    bail: 1,
+
+    // A preset that is used as a base for Jest's configuration
+    preset: "ts-jest",
+
+    // A set of global variables that need to be available in all test environments
+    globals: {
+        "ts-jest": {
+            tsconfig: "<rootDir>/config/tsconfig.test.json",
+        },
+    },
+
+    // The root directory that Jest should scan for tests and modules within
+    rootDir: "../",
+
+    // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+    testPathIgnorePatterns: ["/node_modules/", "<rootDir>/build/"],
+
+    // A map from regular expressions to paths to transformers
+    transform: {
+        [String.raw`\.(ts|tsx)$`]: "ts-jest",
+    },
+
+    // Indicates whether each individual test should be reported during the run
+    verbose: true,
+
+    // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+    watchPathIgnorePatterns: ["<rootDir>/build/", "dist/"],
+};
+
+export default config;

package/config/tsconfig.script.json

@@ -0,0 +1,10 @@
+{
+    "extends": "../../../tsconfig.base.json",
+    "compilerOptions": {
+        "lib": ["ES2020"],
+        "module": "CommonJS",
+        "target": "ES2015",
+        "noEmit": true
+    },
+    "include": ["../config", "../script/"]
+}

package/config/tsconfig.src.json

@@ -0,0 +1,12 @@
+{
+    "extends": "../../../tsconfig.base.json",
+    "compilerOptions": {
+        "lib": ["ES2020"],
+        "module": "CommonJS",
+        "target": "ES2015",
+        "rootDir": "../",
+        "outDir": "../build/",
+        "isolatedModules": true
+    },
+    "include": ["../src/"]
+}

package/config/tsconfig.test.json

@@ -0,0 +1,11 @@
+{
+    "extends": "../../../tsconfig.base.json",
+    "compilerOptions": {
+        "lib": ["ES2020"],
+        "module": "CommonJS",
+        "target": "ES2015",
+        "rootDir": "../",
+        "isolatedModules": true
+    },
+    "include": ["../test/"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pinnacle0/webpack-util",
-    "version": "0.3.25",
+    "version": "0.3.26",
     "license": "MIT",
     "main": "src/index.js",
     "scripts": {
@@ -12,7 +12,7 @@
     "dependencies": {
         "@babel/core": "7.18.6",
         "@pmmmwh/react-refresh-webpack-plugin": "0.5.7",
-        "@swc/core": "1.2.209",
+        "@swc/core": "1.2.210",
         "autoprefixer": "10.4.7",
         "babel-loader": "8.2.5",
         "css-loader": "6.7.1",

package/script/build.ts

@@ -0,0 +1,65 @@
+import {PrettierUtil, TaskRunner, Utility} from "@pinnacle0/devtool-util";
+import fs from "fs";
+import path from "path";
+
+const FilePath = {
+    config: path.join(__dirname, "../config"),
+    build: path.join(__dirname, "../build"),
+    script: path.join(__dirname, "../script"),
+    src: path.join(__dirname, "../src"),
+
+    jestConfig: path.join(__dirname, "../config/jest.config.ts"),
+    tsConfigForSrc: path.join(__dirname, "../config/tsconfig.src.json"),
+    projectPackageJSON: path.join(__dirname, "../package.json"),
+    projectReadMe: path.join(__dirname, "../README.md"),
+    projectLicense: path.join(__dirname, "../LICENSE.md"),
+    buildPackageJSON: path.join(__dirname, "../build/package.json"),
+    buildReadMe: path.join(__dirname, "../build/README.md"),
+    buildLicense: path.join(__dirname, "../build/LICENSE.md"),
+};
+
+new TaskRunner("build").execute([
+    {
+        name: "code style check",
+        skipInFastMode: true,
+        execute: () => {
+            PrettierUtil.check(FilePath.config);
+            PrettierUtil.check(FilePath.script);
+            PrettierUtil.check(FilePath.src);
+        },
+    },
+    {
+        name: "lint",
+        skipInFastMode: true,
+        execute: () => {
+            Utility.runCommand("eslint", ["--ext=.js,.jsx,.ts,.tsx", FilePath.src]);
+        },
+    },
+    {
+        name: "test",
+        skipInFastMode: true,
+        execute: () => {
+            Utility.runCommand("jest", ["--config", FilePath.jestConfig, "--bail"]);
+        },
+    },
+    {
+        name: "prepare build directory",
+        execute: () => {
+            Utility.prepareEmptyDirectory(FilePath.build);
+        },
+    },
+    {
+        name: "compile with tsc",
+        execute: () => {
+            Utility.runCommand("tsc", ["--project", FilePath.tsConfigForSrc]);
+        },
+    },
+    {
+        name: "copy package.json, markdown files",
+        execute: () => {
+            fs.copyFileSync(FilePath.projectPackageJSON, FilePath.buildPackageJSON);
+            fs.copyFileSync(FilePath.projectReadMe, FilePath.buildReadMe);
+            fs.copyFileSync(FilePath.projectLicense, FilePath.buildLicense);
+        },
+    },
+]);

package/script/format.ts

@@ -0,0 +1,7 @@
+import {PrettierUtil} from "@pinnacle0/devtool-util";
+import path from "path";
+
+PrettierUtil.format(path.join(__dirname, "../config"));
+PrettierUtil.format(path.join(__dirname, "../script"));
+PrettierUtil.format(path.join(__dirname, "../src"));
+PrettierUtil.format(path.join(__dirname, "../test"));

package/src/CanadyarnRunner.ts

@@ -0,0 +1,35 @@
+import {Utility} from "@pinnacle0/devtool-util";
+import fs from "fs";
+
+/**
+ * `canadyarn` is a mono-repo package version checker for single version installation, developed by Pinnacle team.
+ *
+ * Ref: https://www.npmjs.com/package/canadyarn
+ */
+export class CanadyarnRunner {
+    private readonly rootDirectory: string;
+    private readonly logger = Utility.createConsoleLogger("CanadyarnRunner");
+
+    constructor({rootDirectory}: {rootDirectory: string}) {
+        this.rootDirectory = rootDirectory;
+    }
+
+    run() {
+        this.runCanadyarn();
+    }
+
+    private runCanadyarn() {
+        const packageJSONPath = this.rootDirectory + "/package.json";
+
+        if (fs.existsSync(packageJSONPath) && fs.statSync(packageJSONPath).isFile()) {
+            const packageJSONContents: Record<string, any> = JSON.parse(fs.readFileSync(packageJSONPath, {encoding: "utf8"}));
+
+            if (packageJSONContents?.scripts?.canadyarn) {
+                this.logger.task("Running `canadyarn` at " + this.rootDirectory);
+                Utility.runCommand("yarn", ["--cwd", this.rootDirectory, "canadyarn"]);
+            }
+        } else {
+            throw new Error(`Cannot load root directory [${this.rootDirectory}] package.json`);
+        }
+    }
+}

package/src/CodeStyleChecker.ts

@@ -0,0 +1,44 @@
+import {PrettierUtil, Utility} from "@pinnacle0/devtool-util";
+import fs from "fs";
+import path from "path";
+import type {InternalCheckerOptions} from "./type";
+
+export class CodeStyleChecker {
+    private readonly checkableSrcDirectories: [string, ...string[]];
+    private readonly logger = Utility.createConsoleLogger("CodeStyleChecker");
+
+    constructor({projectDirectory, extraCheckDirectories = []}: InternalCheckerOptions) {
+        this.checkableSrcDirectories = [path.join(projectDirectory, "src")];
+        for (const directory of extraCheckDirectories) {
+            const others = ["test", "script"].map(folder => path.join(directory, folder)).filter(path => fs.existsSync(path));
+            this.checkableSrcDirectories.push(path.join(directory, "src"), ...others);
+        }
+    }
+
+    run() {
+        this.checkPrettier();
+        this.checkESLint();
+        this.checkStylelint();
+    }
+
+    private checkPrettier() {
+        this.logger.task("Checking Prettier");
+        for (const srcDirectory of this.checkableSrcDirectories) {
+            PrettierUtil.check(srcDirectory);
+        }
+    }
+
+    private checkESLint() {
+        this.logger.task("Checking ESLint");
+        for (const srcDirectory of this.checkableSrcDirectories) {
+            Utility.runCommand("eslint", ["--no-error-on-unmatched-pattern", "--max-warnings=1", "--ext=.js,.jsx,.ts,.tsx", srcDirectory]);
+        }
+    }
+
+    private checkStylelint() {
+        this.logger.task("Checking Stylelint");
+        for (const srcDirectory of this.checkableSrcDirectories) {
+            Utility.runCommand("stylelint", ["--allow-empty-input", "--max-warnings=1", path.join(srcDirectory, "**/*.{css,less}")]);
+        }
+    }
+}

package/src/{Constant.js → Constant.ts}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Constant = void 0;
-exports.Constant = Object.freeze({
+export const Constant = Object.freeze({
     maxEntryPointKiloByte: 1500,
     maxAssetKiloByte: 4000,
     /**
@@ -22,4 +19,3 @@ exports.Constant = Object.freeze({
      */
     mainEntryFilenames: ["index.tsx", "index.ts", "index.jsx", "index.js", "index.less", "index.css"],
 });
-//# sourceMappingURL=Constant.js.map

package/src/CoreUtil.ts

@@ -0,0 +1,24 @@
+import yargs from "yargs";
+
+function currentEnv(): string | null {
+    return (yargs.parseSync().env as string) || null;
+}
+
+function profilingEnabled(): boolean {
+    return Boolean(yargs.parseSync().profile);
+}
+
+function isFastMode(): boolean {
+    return yargs.parseSync().mode === "fast";
+}
+
+function verbose(): boolean {
+    return Boolean(yargs.parseSync().verbose);
+}
+
+export const CoreUtil = Object.freeze({
+    currentEnv,
+    profilingEnabled,
+    isFastMode,
+    verbose,
+});

package/src/ProjectStructureChecker.ts

@@ -0,0 +1,119 @@
+import fs from "fs";
+import path from "path";
+import {Constant} from "./Constant";
+import type {InternalCheckerOptions} from "./type";
+
+export class ProjectStructureChecker {
+    private readonly projectDirectory: string;
+    private readonly extraCheckDirectories: string[];
+    private readonly packageJSONPath: string;
+    private readonly tsConfigPath: string;
+
+    constructor(private readonly options: InternalCheckerOptions) {
+        this.projectDirectory = options.projectDirectory;
+        this.extraCheckDirectories = options.extraCheckDirectories ?? [];
+        this.packageJSONPath = path.join(options.projectDirectory, "package.json");
+        this.tsConfigPath = path.join(options.projectDirectory, "tsconfig.json");
+    }
+
+    run() {
+        this.checkMainProjectDirectory();
+        this.checkMainProjectSrcDirectory();
+        this.checkExtraDirectories();
+        this.checkPackageJSON();
+        this.checkTSConfig();
+
+        this.checkPrettierInstallation();
+        this.checkESLintInstallation();
+        this.checkStyleLintInstallation();
+    }
+
+    private checkMainProjectDirectory() {
+        if (!(fs.existsSync(this.projectDirectory) && fs.statSync(this.projectDirectory).isDirectory())) {
+            throw new Error(`Cannot check project directory at "${this.projectDirectory}" because it is not a folder.`);
+        }
+
+        const mainProjectStaticDirectory = path.join(this.projectDirectory, "static");
+        if (!(fs.existsSync(mainProjectStaticDirectory) && fs.statSync(mainProjectStaticDirectory).isDirectory())) {
+            throw new Error(`Cannot find "static" directory in project at "${this.projectDirectory}"`);
+        }
+    }
+
+    private checkMainProjectSrcDirectory() {
+        const mainProjectSrcDirectory = path.join(this.projectDirectory, "src");
+        if (!(fs.existsSync(mainProjectSrcDirectory) && fs.statSync(mainProjectSrcDirectory).isDirectory())) {
+            throw new Error(`Cannot find "src" folder inside directory at "${this.projectDirectory}".`);
+        }
+
+        let isMainEntryFound = false;
+        Constant.mainEntryFilenames
+            .map(entryName => path.join(mainProjectSrcDirectory, entryName))
+            .forEach(entryPath => {
+                if (fs.existsSync(entryPath) && fs.statSync(entryPath).isFile()) {
+                    isMainEntryFound = true;
+                }
+            });
+        if (!isMainEntryFound) {
+            throw new Error(`Cannot find main entry file in src/ at "${mainProjectSrcDirectory}"; checked: ${Constant.mainEntryFilenames.map(_ => `"${_}"`).join(" / ")}.`);
+        }
+    }
+
+    private checkExtraDirectories() {
+        for (const extraCheckDirectory of this.extraCheckDirectories) {
+            if (!(fs.existsSync(extraCheckDirectory) && fs.statSync(extraCheckDirectory).isDirectory())) {
+                throw new Error(`Cannot check extra directory at "${extraCheckDirectory}" because it is not a folder.`);
+            }
+        }
+    }
+
+    private checkPackageJSON() {
+        if (!(fs.existsSync(this.packageJSONPath) && fs.statSync(this.packageJSONPath).isFile())) {
+            throw new Error(`Cannot find package.json at "${this.packageJSONPath}".`);
+        }
+        const packageJSONContents: Record<string, any> = JSON.parse(fs.readFileSync(this.packageJSONPath, {encoding: "utf8"}));
+        for (const [depName, depVersion] of Object.entries<string>(packageJSONContents.dependencies || {})) {
+            if (!/^\d/.test(depVersion)) {
+                throw new Error(`Dependency "${depName}" must be an exact version, but found "${depVersion}" in package.json at "${this.packageJSONPath}".`);
+            }
+        }
+        for (const [depName, depVersion] of Object.entries<string>(packageJSONContents.devDependencies || {})) {
+            if (!/^\d/.test(depVersion)) {
+                throw new Error(`Dependency "${depName}" must be an exact version, but found "${depVersion}" in package.json at "${this.packageJSONPath}".`);
+            }
+        }
+    }
+
+    private checkTSConfig() {
+        const mainProjectSrcDirectory = path.join(this.projectDirectory, "src");
+        // Checking the first-level of src/* is enough here
+        const hasTSFiles = fs.readdirSync(mainProjectSrcDirectory).some(fileName => fileName.endsWith(".ts") || fileName.endsWith(".tsx"));
+        const hasTSConfigFile = fs.existsSync(this.tsConfigPath) && fs.statSync(this.tsConfigPath).isFile();
+        if (hasTSFiles && !hasTSConfigFile) {
+            throw new Error(`Cannot find tsconfig.json at "${this.tsConfigPath}".`);
+        }
+    }
+
+    private checkPrettierInstallation() {
+        try {
+            require("prettier");
+        } catch {
+            throw new Error(`Cannot load prettier module (requiring from "webpack-util"), make sure prettier is installed.`);
+        }
+    }
+
+    private checkESLintInstallation() {
+        try {
+            require("eslint");
+        } catch {
+            throw new Error(`Cannot load eslint module (requiring from "webpack-util"), make sure eslint is installed.`);
+        }
+    }
+
+    private checkStyleLintInstallation() {
+        try {
+            require("stylelint");
+        } catch {
+            throw new Error(`Cannot load stylelint module (requiring from "webpack-util"), make sure stylelint is installed.`);
+        }
+    }
+}

package/src/TestRunner.ts

@@ -0,0 +1,28 @@
+import {Utility} from "@pinnacle0/devtool-util";
+import type {InternalCheckerOptions} from "./type";
+import fs from "fs";
+
+export class TestRunner {
+    private readonly directories: [string, ...string[]];
+    private readonly logger = Utility.createConsoleLogger("TestRunner");
+
+    constructor({projectDirectory, extraCheckDirectories = []}: InternalCheckerOptions) {
+        this.directories = [projectDirectory, ...extraCheckDirectories];
+    }
+
+    run() {
+        this.directories.forEach(dir => this.runTestScript(dir));
+    }
+
+    private runTestScript(directory: string) {
+        const packageJSONPath = directory + "/package.json";
+        if (fs.existsSync(packageJSONPath) && fs.statSync(packageJSONPath).isFile()) {
+            const packageJSONContents: Record<string, any> = JSON.parse(fs.readFileSync(packageJSONPath, {encoding: "utf8"}));
+
+            if (packageJSONContents?.scripts?.test) {
+                this.logger.task("Running `yarn test` at " + directory);
+                Utility.runCommand("yarn", ["--cwd", directory, "test"]);
+            }
+        }
+    }
+}

package/src/TypescriptTypeChecker.ts

@@ -0,0 +1,29 @@
+import {Utility} from "@pinnacle0/devtool-util";
+import path from "path";
+import type {InternalCheckerOptions} from "./type";
+
+/**
+ * Check typescript type for both projectDirectory src, extraCheckDirectories src using their own tsconfig inside their directory
+ */
+export class TypescriptTypeChecker {
+    private readonly logger = Utility.createConsoleLogger("TypescriptTypeChecker");
+    private tsconfigPaths: string[] = [];
+
+    constructor({projectDirectory, extraCheckDirectories}: InternalCheckerOptions) {
+        const checkableDirectories = [projectDirectory, ...(extraCheckDirectories ?? [])];
+        for (const directory of checkableDirectories) {
+            this.tsconfigPaths.push(path.join(directory, "tsconfig.json"));
+        }
+    }
+
+    run() {
+        this.checkTypeScriptTyping();
+    }
+
+    private checkTypeScriptTyping() {
+        this.logger.task("Checking TypeScript");
+        for (const tsconfigPath of this.tsconfigPaths) {
+            Utility.runCommand("tsc", ["--noEmit", "--emitDeclarationOnly", "false", "-P", tsconfigPath]);
+        }
+    }
+}

package/src/{WebpackBuilder.js → WebpackBuilder.ts}

@@ -1,20 +1,21 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebpackBuilder = void 0;
-const devtool_util_1 = require("@pinnacle0/devtool-util");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const webpack_1 = __importDefault(require("webpack"));
-const CoreUtil_1 = require("./CoreUtil");
-const WebpackConfigGenerator_1 = require("./WebpackConfigGenerator");
-const CanadyarnRunner_1 = require("./CanadyarnRunner");
-const ProjectStructureChecker_1 = require("./ProjectStructureChecker");
-const TypescriptTypeChecker_1 = require("./TypescriptTypeChecker");
-const TestRunner_1 = require("./TestRunner");
-const CodeStyleChecker_1 = require("./CodeStyleChecker");
+import {Utility} from "@pinnacle0/devtool-util";
+import fs from "fs-extra";
+import path from "path";
+import webpack from "webpack";
+import {CoreUtil} from "./CoreUtil";
+import {WebpackConfigGenerator} from "./WebpackConfigGenerator";
+import {CanadyarnRunner} from "./CanadyarnRunner";
+import {ProjectStructureChecker} from "./ProjectStructureChecker";
+import {TypescriptTypeChecker} from "./TypescriptTypeChecker";
+import {TestRunner} from "./TestRunner";
+import {CodeStyleChecker} from "./CodeStyleChecker";
+import type {InternalCheckerOptions} from "./type";
+import type {WebpackConfigGeneratorOptions} from "./WebpackConfigGenerator";
+
+export interface WebpackBuilderOptions extends WebpackConfigGeneratorOptions, InternalCheckerOptions {
+    onSuccess?: () => void;
+}
+
 /**
  * Build the website by webpack.
  *
@@ -29,40 +30,55 @@ const CodeStyleChecker_1 = require("./CodeStyleChecker");
  *
  * Add "--mode fast" to command line, if you want to skip style and lint checks.
  */
-class WebpackBuilder {
-    constructor(options) {
-        var _a;
-        this.logger = devtool_util_1.Utility.createConsoleLogger("WebpackBuilder");
-        const webpackConfigGenerator = new WebpackConfigGenerator_1.WebpackConfigGenerator(options);
+export class WebpackBuilder {
+    private readonly projectDirectory: string;
+    private readonly rootDirectory: string;
+    private readonly extraCheckDirectories: string[];
+    private readonly projectStaticDirectory: string;
+    private readonly projectProfilingJSONOutputPath: string;
+    private readonly outputDirectory: string;
+    private readonly webpackConfig: webpack.Configuration;
+    private readonly isFastMode: boolean;
+    private readonly enableProfiling: boolean;
+    private readonly onSuccess?: (() => void) | undefined;
+
+    private readonly logger = Utility.createConsoleLogger("WebpackBuilder");
+
+    constructor(options: WebpackBuilderOptions) {
+        const webpackConfigGenerator = new WebpackConfigGenerator(options);
+
         this.projectDirectory = options.projectDirectory;
         this.rootDirectory = options.rootDirectory ? options.rootDirectory : this.projectDirectory;
-        this.extraCheckDirectories = (_a = options.extraCheckDirectories) !== null && _a !== void 0 ? _a : [];
-        this.projectStaticDirectory = path_1.default.join(this.projectDirectory, "static");
-        this.projectProfilingJSONOutputPath = path_1.default.join(this.projectDirectory, "profile.json");
-        this.outputDirectory = path_1.default.join(this.projectDirectory, "build/dist");
-        this.isFastMode = CoreUtil_1.CoreUtil.isFastMode();
-        this.enableProfiling = CoreUtil_1.CoreUtil.profilingEnabled();
+        this.extraCheckDirectories = options.extraCheckDirectories ?? [];
+        this.projectStaticDirectory = path.join(this.projectDirectory, "static");
+        this.projectProfilingJSONOutputPath = path.join(this.projectDirectory, "profile.json");
+        this.outputDirectory = path.join(this.projectDirectory, "build/dist");
+
+        this.isFastMode = CoreUtil.isFastMode();
+        this.enableProfiling = CoreUtil.profilingEnabled();
         this.onSuccess = options.onSuccess;
+
         this.webpackConfig = webpackConfigGenerator.production(this.outputDirectory);
     }
+
     run() {
         if (!this.isFastMode) {
-            new CanadyarnRunner_1.CanadyarnRunner({
+            new CanadyarnRunner({
                 rootDirectory: this.rootDirectory,
             }).run();
-            new ProjectStructureChecker_1.ProjectStructureChecker({
+            new ProjectStructureChecker({
                 projectDirectory: this.projectDirectory,
                 extraCheckDirectories: this.extraCheckDirectories,
             }).run();
-            new TypescriptTypeChecker_1.TypescriptTypeChecker({
+            new TypescriptTypeChecker({
                 projectDirectory: this.projectDirectory,
                 extraCheckDirectories: this.extraCheckDirectories,
             }).run();
-            new TestRunner_1.TestRunner({
+            new TestRunner({
                 projectDirectory: this.projectDirectory,
                 extraCheckDirectories: this.extraCheckDirectories,
             }).run();
-            new CodeStyleChecker_1.CodeStyleChecker({
+            new CodeStyleChecker({
                 projectDirectory: this.projectDirectory,
                 extraCheckDirectories: this.extraCheckDirectories,
             }).run();
@@ -71,46 +87,52 @@ class WebpackBuilder {
         this.copyStatic();
         this.bundleByWebpack();
     }
-    cleanDistFolder() {
+
+    private cleanDistFolder() {
         this.logger.task("Cleaning build dist folder");
-        fs_extra_1.default.emptyDirSync(this.outputDirectory);
+        fs.emptyDirSync(this.outputDirectory);
     }
-    copyStatic() {
+
+    private copyStatic() {
         this.logger.task("Copying static assets to build dist folder");
-        fs_extra_1.default.copySync(this.projectStaticDirectory, this.outputDirectory, { dereference: true });
+        fs.copySync(this.projectStaticDirectory, this.outputDirectory, {dereference: true});
     }
-    bundleByWebpack() {
+
+    private bundleByWebpack() {
         this.logger.task("Starting webpack");
-        (0, webpack_1.default)(this.webpackConfig).run((error, stats) => {
+
+        webpack(this.webpackConfig).run((error?: Error | null, stats?: webpack.Stats) => {
             if (error) {
                 throw error;
-            }
-            else if (stats) {
+            } else if (stats) {
                 const statsJSON = stats.toJson();
                 if (this.enableProfiling) {
                     this.logger.task(["Generating profile for analysis", this.projectProfilingJSONOutputPath]);
-                    fs_extra_1.default.writeFileSync(this.projectProfilingJSONOutputPath, JSON.stringify(statsJSON, null, 2), { encoding: "utf8" });
+                    fs.writeFileSync(this.projectProfilingJSONOutputPath, JSON.stringify(statsJSON, null, 2), {encoding: "utf8"});
                 }
+
                 if (stats.hasErrors() || stats.hasWarnings()) {
                     this.logger.error("Webpack compiled with the following errors/warnings:");
                     console.error(stats.toString("errors-warnings"));
                     process.exit(1);
                 }
+
                 this.logger.info("Build successfully");
+
                 if (this.onSuccess) {
                     this.logger.info("Running onSuccess callback");
                     this.onSuccess();
                 }
-            }
-            else {
+            } else {
                 this.logger.error("Webpack compiler `run()` returns no `error` and no `stats`, this is unexpected.");
                 process.exit(1);
             }
         });
     }
-    getRawWarningsAndErrors(info) {
-        const warnings = [];
-        const errors = [];
+
+    private getRawWarningsAndErrors(info: any): {warnings: any[]; errors: any[]} {
+        const warnings: any[] = [];
+        const errors: any[] = [];
         if (typeof info === "object" && info !== null) {
             if (Array.isArray(info.warnings)) {
                 warnings.push(...info.warnings);
@@ -119,15 +141,13 @@ class WebpackBuilder {
                 errors.push(...info.errors);
             }
             if (Array.isArray(info.children)) {
-                info.children.forEach((_) => {
+                info.children.forEach((_: any) => {
                     const childInfo = this.getRawWarningsAndErrors(_);
                     warnings.push(...childInfo.warnings);
                     errors.push(...childInfo.errors);
                 });
             }
         }
-        return { warnings, errors };
+        return {warnings, errors};
     }
 }
-exports.WebpackBuilder = WebpackBuilder;
-//# sourceMappingURL=WebpackBuilder.js.map