From 39ebae6e8637ca756746f56e865ab793c0b20dfa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Piotr=20Ole=C5=9B?= <piotrek.oles@gmail.com>
Date: Sat, 22 Jan 2022 20:43:22 +0100
Subject: [PATCH] refactor: rename files to match convention (#693)

I found snake-case easier to read, and given that
the project doesn't use OOP a lot, having all PascalCase
names doesn't reflect the paradigm and feels unnatural.
---
 README.md                                     |  2 +-
 release.config.js                             |  3 +-
 ...ForkTsCheckerWebpackPluginConfiguration.ts | 34 --------
 src/files-change.ts                           | 44 +++++++----
 .../{BasicFormatter.ts => basic-formatter.ts} |  2 +-
 ...meFormatter.ts => code-frame-formatter.ts} |  4 +-
 ...erConfiguration.ts => formatter-config.ts} | 20 +++--
 ...rmatterOptions.ts => formatter-options.ts} |  2 +-
 src/formatter/{Formatter.ts => formatter.ts}  |  0
 src/formatter/index.ts                        | 12 +--
 ...bpackFormatter.ts => webpack-formatter.ts} |  4 +-
 ...> intercept-done-to-get-dev-server-tap.ts} | 16 ++--
 ... tap-after-compile-to-add-dependencies.ts} |  6 +-
 ....ts => tap-after-compile-to-get-issues.ts} | 17 ++--
 ...ap-after-environment-to-patch-watching.ts} |  6 +-
 ...ues.ts => tap-done-to-async-get-issues.ts} | 31 ++++----
 ...Message.ts => tap-error-to-log-message.ts} | 17 ++--
 ...Workers.ts => tap-start-to-run-workers.ts} | 26 +++----
 ...rs.ts => tap-stop-to-terminate-workers.ts} |  4 +-
 src/index.ts                                  |  2 +-
 src/infrastructure-logger.ts                  |  2 +-
 src/issue/index.ts                            |  6 +-
 ...{IssueConfiguration.ts => issue-config.ts} | 16 ++--
 .../{IssueLocation.ts => issue-location.ts}   |  4 +-
 src/issue/{IssueMatch.ts => issue-match.ts}   |  4 +-
 .../{IssueOptions.ts => issue-options.ts}     |  4 +-
 .../{IssuePosition.ts => issue-position.ts}   |  0
 .../{IssuePredicate.ts => issue-predicate.ts} |  0
 .../{IssueSeverity.ts => issue-severity.ts}   |  0
 ...WebpackError.ts => issue-webpack-error.ts} |  6 +-
 src/issue/{Issue.ts => issue.ts}              |  8 +-
 ...oggerConfiguration.ts => logger-config.ts} | 14 ++--
 .../{LoggerFactory.ts => logger-factory.ts}   |  6 +-
 .../{LoggerOptions.ts => logger-options.ts}   |  4 +-
 src/logger/{Logger.ts => logger.ts}           |  0
 .../{PartialLogger.ts => partial-logger.ts}   |  2 +-
 ...er.ts => webpack-infrastructure-logger.ts} |  2 +-
 src/plugin-config.ts                          | 34 ++++++++
 src/{hooks/pluginHooks.ts => plugin-hooks.ts} | 20 ++---
 ...PluginOptions.json => plugin-options.json} |  0
 ...packPluginOptions.ts => plugin-options.ts} |  8 +-
 src/{hooks/pluginPools.ts => plugin-pools.ts} |  4 +-
 ...rWebpackPluginState.ts => plugin-state.ts} |  4 +-
 ...orkTsCheckerWebpackPlugin.ts => plugin.ts} | 54 +++++++------
 .../rpc/expose.ts => rpc/expose-rpc.ts}       |  0
 src/rpc/index.ts                              |  5 ++
 src/{utils/rpc/error.ts => rpc/rpc-error.ts}  |  0
 .../rpc/worker.ts => rpc/rpc-worker.ts}       |  2 +-
 src/{utils => }/rpc/types.ts                  |  0
 src/{utils/rpc/wrap.ts => rpc/wrap-rpc.ts}    |  2 +-
 ...n.ts => type-script-embedded-extension.ts} |  2 +-
 ...tExtension.ts => type-script-extension.ts} |  0
 .../TypeScriptVueExtensionConfiguration.ts    | 18 -----
 .../vue/type-script-vue-extension-config.ts   | 18 +++++
 ...s => type-script-vue-extension-options.ts} |  0
 ...s => type-script-vue-extension-support.ts} |  6 +-
 ...ension.ts => type-script-vue-extension.ts} | 14 ++--
 ...ite.ts => type-script-config-overwrite.ts} |  4 +-
 ....ts => type-script-diagnostics-options.ts} |  0
 ...criptSupport.ts => type-script-support.ts} | 18 ++---
 ...ration.ts => type-script-worker-config.ts} | 28 +++----
 ...tions.ts => type-script-worker-options.ts} | 12 +--
 .../worker/get-dependencies-worker.ts         |  2 +-
 src/typescript/worker/get-issues-worker.ts    |  2 +-
 src/typescript/worker/lib/artifacts.ts        |  4 +-
 src/typescript/worker/lib/config.ts           |  6 +-
 src/typescript/worker/lib/dependencies.ts     |  4 +-
 src/typescript/worker/lib/extensions.ts       |  4 +-
 src/typescript/worker/lib/system.ts           |  2 +-
 src/typescript/worker/lib/worker-config.ts    |  6 +-
 src/utils/array/flatten.ts                    |  5 --
 src/utils/array/intersect.ts                  |  5 --
 src/utils/array/substract.ts                  |  5 --
 src/utils/array/unique.ts                     |  5 --
 .../async/{isPending.ts => is-pending.ts}     |  2 +-
 src/utils/async/wait.ts                       |  2 +-
 .../{forwardSlash.ts => forward-slash.ts}     |  2 +-
 ...iveToContext.ts => relative-to-context.ts} |  2 +-
 src/utils/rpc/index.ts                        |  5 --
 ...ts => inclusive-node-watch-file-system.ts} | 55 ++++++++++---
 ...atchFileSystem.ts => watch-file-system.ts} |  2 +-
 test/e2e/driver/{Listener.ts => listener.ts}  |  0
 ...Driver.ts => webpack-dev-server-driver.ts} |  6 +-
 ...tractor.ts => webpack-errors-extractor.ts} |  0
 ... => out-of-memory-and-cosmiconfig.spec.ts} |  0
 ...tions.spec.ts => type-definitions.spec.ts} |  0
 ...ion.spec.ts => type-script-config.spec.ts} |  6 +-
 ....ts => type-script-context-option.spec.ts} |  2 +-
 ...s => type-script-formatter-option.spec.ts} |  2 +-
 ...pec.ts => type-script-pnp-support.spec.ts} |  2 +-
 ... type-script-solution-builder-api.spec.ts} |  2 +-
 ...c.ts => type-script-vue-extension.spec.ts} |  2 +-
 ....spec.ts => type-script-watch-api.spec.ts} |  2 +-
 ...deApi.spec.ts => webpack-node-api.spec.ts} |  0
 ...ec.ts => webpack-production-build.spec.ts} |  2 +-
 test/tsconfig.json                            |  3 +-
 test/unit/files-change.spec.ts                | 78 +++++++++++++++++++
 ...matter.spec.ts => basic-formatter.spec.ts} |  6 +-
 ...r.spec.ts => code-frame-formatter.spec.ts} |  6 +-
 ...ation.spec.ts => formatter-config.spec.ts} | 10 +--
 ...tter.spec.ts => webpack-formatter.spec.ts} |  8 +-
 .../issue/{Issue.spec.ts => issue.spec.ts}    |  6 +-
 test/unit/jest.config.js                      |  2 +-
 ...erWebpackPlugin.spec.ts => plugin.spec.ts} |  4 +-
 ...rt.spec.ts => type-script-support.spec.ts} | 14 ++--
 ...c.ts => type-script-worker-config.spec.ts} | 43 +++++-----
 test/unit/utils/async/pool.spec.ts            |  2 +-
 107 files changed, 499 insertions(+), 412 deletions(-)
 delete mode 100644 src/ForkTsCheckerWebpackPluginConfiguration.ts
 rename src/formatter/{BasicFormatter.ts => basic-formatter.ts} (82%)
 rename src/formatter/{CodeFrameFormatter.ts => code-frame-formatter.ts} (89%)
 rename src/formatter/{FormatterConfiguration.ts => formatter-config.ts} (56%)
 rename src/formatter/{FormatterOptions.ts => formatter-options.ts} (91%)
 rename src/formatter/{Formatter.ts => formatter.ts} (100%)
 rename src/formatter/{WebpackFormatter.ts => webpack-formatter.ts} (87%)
 rename src/hooks/{interceptDoneToGetWebpackDevServerTap.ts => intercept-done-to-get-dev-server-tap.ts} (51%)
 rename src/hooks/{tapAfterCompileToAddDependencies.ts => tap-after-compile-to-add-dependencies.ts} (77%)
 rename src/hooks/{tapAfterCompileToGetIssues.ts => tap-after-compile-to-get-issues.ts} (68%)
 rename src/hooks/{tapAfterEnvironmentToPatchWatching.ts => tap-after-environment-to-patch-watching.ts} (78%)
 rename src/hooks/{tapDoneToAsyncGetIssues.ts => tap-done-to-async-get-issues.ts} (66%)
 rename src/hooks/{tapErrorToLogMessage.ts => tap-error-to-log-message.ts} (68%)
 rename src/hooks/{tapStartToRunWorkers.ts => tap-start-to-run-workers.ts} (77%)
 rename src/hooks/{tapStopToTerminateWorkers.ts => tap-stop-to-terminate-workers.ts} (86%)
 rename src/issue/{IssueConfiguration.ts => issue-config.ts} (75%)
 rename src/issue/{IssueLocation.ts => issue-location.ts} (89%)
 rename src/issue/{IssueMatch.ts => issue-match.ts} (86%)
 rename src/issue/{IssueOptions.ts => issue-options.ts} (69%)
 rename src/issue/{IssuePosition.ts => issue-position.ts} (100%)
 rename src/issue/{IssuePredicate.ts => issue-predicate.ts} (100%)
 rename src/issue/{IssueSeverity.ts => issue-severity.ts} (100%)
 rename src/issue/{IssueWebpackError.ts => issue-webpack-error.ts} (82%)
 rename src/issue/{Issue.ts => issue.ts} (85%)
 rename src/logger/{LoggerConfiguration.ts => logger-config.ts} (60%)
 rename src/logger/{LoggerFactory.ts => logger-factory.ts} (77%)
 rename src/logger/{LoggerOptions.ts => logger-options.ts} (63%)
 rename src/logger/{Logger.ts => logger.ts} (100%)
 rename src/logger/{PartialLogger.ts => partial-logger.ts} (92%)
 rename src/logger/{WebpackInfrastructureLogger.ts => webpack-infrastructure-logger.ts} (94%)
 create mode 100644 src/plugin-config.ts
 rename src/{hooks/pluginHooks.ts => plugin-hooks.ts} (69%)
 rename src/{ForkTsCheckerWebpackPluginOptions.json => plugin-options.json} (100%)
 rename src/{ForkTsCheckerWebpackPluginOptions.ts => plugin-options.ts} (50%)
 rename src/{hooks/pluginPools.ts => plugin-pools.ts} (68%)
 rename src/{ForkTsCheckerWebpackPluginState.ts => plugin-state.ts} (80%)
 rename src/{ForkTsCheckerWebpackPlugin.ts => plugin.ts} (51%)
 rename src/{utils/rpc/expose.ts => rpc/expose-rpc.ts} (100%)
 create mode 100644 src/rpc/index.ts
 rename src/{utils/rpc/error.ts => rpc/rpc-error.ts} (100%)
 rename src/{utils/rpc/worker.ts => rpc/rpc-worker.ts} (98%)
 rename src/{utils => }/rpc/types.ts (100%)
 rename src/{utils/rpc/wrap.ts => rpc/wrap-rpc.ts} (98%)
 rename src/typescript/extension/{TypeScriptEmbeddedExtension.ts => type-script-embedded-extension.ts} (98%)
 rename src/typescript/extension/{TypeScriptExtension.ts => type-script-extension.ts} (100%)
 delete mode 100644 src/typescript/extension/vue/TypeScriptVueExtensionConfiguration.ts
 create mode 100644 src/typescript/extension/vue/type-script-vue-extension-config.ts
 rename src/typescript/extension/vue/{TypeScriptVueExtensionOptions.ts => type-script-vue-extension-options.ts} (100%)
 rename src/typescript/extension/vue/{TypeScriptVueExtensionSupport.ts => type-script-vue-extension-support.ts} (74%)
 rename src/typescript/extension/vue/{TypeScriptVueExtension.ts => type-script-vue-extension.ts} (89%)
 rename src/typescript/{TypeScriptConfigurationOverwrite.ts => type-script-config-overwrite.ts} (68%)
 rename src/typescript/{TypeScriptDiagnosticsOptions.ts => type-script-diagnostics-options.ts} (100%)
 rename src/typescript/{TypeScriptSupport.ts => type-script-support.ts} (71%)
 rename src/typescript/{TypeScriptReporterConfiguration.ts => type-script-worker-config.ts} (68%)
 rename src/typescript/{TypeScriptReporterOptions.ts => type-script-worker-options.ts} (53%)
 delete mode 100644 src/utils/array/flatten.ts
 delete mode 100644 src/utils/array/intersect.ts
 delete mode 100644 src/utils/array/substract.ts
 delete mode 100644 src/utils/array/unique.ts
 rename src/utils/async/{isPending.ts => is-pending.ts} (89%)
 rename src/utils/path/{forwardSlash.ts => forward-slash.ts} (87%)
 rename src/utils/path/{relativeToContext.ts => relative-to-context.ts} (86%)
 delete mode 100644 src/utils/rpc/index.ts
 rename src/watch/{InclusiveNodeWatchFileSystem.ts => inclusive-node-watch-file-system.ts} (76%)
 rename src/watch/{WatchFileSystem.ts => watch-file-system.ts} (95%)
 rename test/e2e/driver/{Listener.ts => listener.ts} (100%)
 rename test/e2e/driver/{WebpackDevServerDriver.ts => webpack-dev-server-driver.ts} (95%)
 rename test/e2e/driver/{WebpackErrorsExtractor.ts => webpack-errors-extractor.ts} (100%)
 rename test/e2e/{OutOfMemoryAndCosmiconfig.spec.ts => out-of-memory-and-cosmiconfig.spec.ts} (100%)
 rename test/e2e/{TypeDefinitions.spec.ts => type-definitions.spec.ts} (100%)
 rename test/e2e/{TypeScriptConfiguration.spec.ts => type-script-config.spec.ts} (92%)
 rename test/e2e/{TypeScriptContextOption.spec.ts => type-script-context-option.spec.ts} (97%)
 rename test/e2e/{TypeScriptFormatterOption.spec.ts => type-script-formatter-option.spec.ts} (95%)
 rename test/e2e/{TypeScriptPnpSupport.spec.ts => type-script-pnp-support.spec.ts} (98%)
 rename test/e2e/{TypeScriptSolutionBuilderApi.spec.ts => type-script-solution-builder-api.spec.ts} (98%)
 rename test/e2e/{TypeScriptVueExtension.spec.ts => type-script-vue-extension.spec.ts} (97%)
 rename test/e2e/{TypeScriptWatchApi.spec.ts => type-script-watch-api.spec.ts} (99%)
 rename test/e2e/{WebpackNodeApi.spec.ts => webpack-node-api.spec.ts} (100%)
 rename test/e2e/{WebpackProductionBuild.spec.ts => webpack-production-build.spec.ts} (97%)
 create mode 100644 test/unit/files-change.spec.ts
 rename test/unit/formatter/{BasicFormatter.spec.ts => basic-formatter.spec.ts} (83%)
 rename test/unit/formatter/{CodeFrameFormatter.spec.ts => code-frame-formatter.spec.ts} (94%)
 rename test/unit/formatter/{FormatterConfiguration.spec.ts => formatter-config.spec.ts} (86%)
 rename test/unit/formatter/{WebpackFormatter.spec.ts => webpack-formatter.spec.ts} (86%)
 rename test/unit/issue/{Issue.spec.ts => issue.spec.ts} (97%)
 rename test/unit/{ForkTsCheckerWebpackPlugin.spec.ts => plugin.spec.ts} (88%)
 rename test/unit/typescript/{TypeScriptSupport.spec.ts => type-script-support.spec.ts} (80%)
 rename test/unit/typescript/{TypeScriptReporterConfiguration.spec.ts => type-script-worker-config.spec.ts} (67%)

diff --git a/README.md b/README.md
index 918a4be7..c355bf33 100644
--- a/README.md
+++ b/README.md
@@ -139,7 +139,7 @@ type IssueFilter = IssueMatch | IssuePredicate | (IssueMatch | IssuePredicate)[]
 
 | Name      | Type          | Default value | Description |
 | --------- | ------------- | ------------- | ----------- |
-| `include` | `IssueFilter` | `undefined`   | If `object`, defines issue properties that should be [matched](./src/issue/IssueMatch.ts). If `function`, acts as a predicate where `issue` is an argument. |
+| `include` | `IssueFilter` | `undefined`   | If `object`, defines issue properties that should be [matched](src/issue/issue-match.ts). If `function`, acts as a predicate where `issue` is an argument. |
 | `exclude` | `IssueFilter` | `undefined`   | Same as `include` but issues that match this predicate will be excluded. |
 
 <details>
diff --git a/release.config.js b/release.config.js
index e991a523..4aa4d2a7 100644
--- a/release.config.js
+++ b/release.config.js
@@ -32,8 +32,7 @@ module.exports = {
     [
       '@semantic-release/exec',
       {
-        prepareCmd:
-          "sed -i 's/{{VERSION}}/${nextRelease.version}/g' lib/ForkTsCheckerWebpackPlugin.js",
+        prepareCmd: "sed -i 's/{{VERSION}}/${nextRelease.version}/g' lib/plugin.js",
       },
     ],
   ],
diff --git a/src/ForkTsCheckerWebpackPluginConfiguration.ts b/src/ForkTsCheckerWebpackPluginConfiguration.ts
deleted file mode 100644
index b9f3b031..00000000
--- a/src/ForkTsCheckerWebpackPluginConfiguration.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import type webpack from 'webpack';
-
-import type { ForkTsCheckerWebpackPluginOptions } from './ForkTsCheckerWebpackPluginOptions';
-import type { FormatterConfiguration } from './formatter';
-import { createFormatterConfiguration } from './formatter';
-import type { IssueConfiguration } from './issue/IssueConfiguration';
-import { createIssueConfiguration } from './issue/IssueConfiguration';
-import type { LoggerConfiguration } from './logger/LoggerConfiguration';
-import { createLoggerConfiguration } from './logger/LoggerConfiguration';
-import type { TypeScriptReporterConfiguration } from './typescript/TypeScriptReporterConfiguration';
-import { createTypeScriptReporterConfiguration } from './typescript/TypeScriptReporterConfiguration';
-
-interface ForkTsCheckerWebpackPluginConfiguration {
-  async: boolean;
-  typescript: TypeScriptReporterConfiguration;
-  issue: IssueConfiguration;
-  formatter: FormatterConfiguration;
-  logger: LoggerConfiguration;
-}
-
-function createForkTsCheckerWebpackPluginConfiguration(
-  compiler: webpack.Compiler,
-  options: ForkTsCheckerWebpackPluginOptions = {}
-): ForkTsCheckerWebpackPluginConfiguration {
-  return {
-    async: options.async === undefined ? compiler.options.mode === 'development' : options.async,
-    typescript: createTypeScriptReporterConfiguration(compiler, options.typescript),
-    issue: createIssueConfiguration(compiler, options.issue),
-    formatter: createFormatterConfiguration(options.formatter),
-    logger: createLoggerConfiguration(compiler, options.logger),
-  };
-}
-
-export { ForkTsCheckerWebpackPluginConfiguration, createForkTsCheckerWebpackPluginConfiguration };
diff --git a/src/files-change.ts b/src/files-change.ts
index 591d8096..d47cd116 100644
--- a/src/files-change.ts
+++ b/src/files-change.ts
@@ -1,8 +1,5 @@
 import type * as webpack from 'webpack';
 
-import subtract from './utils/array/substract';
-import unique from './utils/array/unique';
-
 interface FilesChange {
   changedFiles?: string[];
   deletedFiles?: string[];
@@ -14,6 +11,12 @@ function getFilesChange(compiler: webpack.Compiler): FilesChange {
   return compilerFilesChangeMap.get(compiler) || { changedFiles: [], deletedFiles: [] };
 }
 
+function consumeFilesChange(compiler: webpack.Compiler): FilesChange {
+  const change = getFilesChange(compiler);
+  clearFilesChange(compiler);
+  return change;
+}
+
 function updateFilesChange(compiler: webpack.Compiler, change: FilesChange): void {
   compilerFilesChangeMap.set(compiler, aggregateFilesChanges([getFilesChange(compiler), change]));
 }
@@ -29,22 +32,31 @@ function clearFilesChange(compiler: webpack.Compiler): void {
  * @returns Files change that represents all subsequent changes as a one event
  */
 function aggregateFilesChanges(changes: FilesChange[]): FilesChange {
-  let changedFiles: string[] = [];
-  let deletedFiles: string[] = [];
-
-  for (const change of changes) {
-    changedFiles = unique(
-      subtract(changedFiles, change.deletedFiles).concat(change.changedFiles || [])
-    );
-    deletedFiles = unique(
-      subtract(deletedFiles, change.changedFiles).concat(change.deletedFiles || [])
-    );
+  const changedFilesSet = new Set<string>();
+  const deletedFilesSet = new Set<string>();
+
+  for (const { changedFiles = [], deletedFiles = [] } of changes) {
+    for (const changedFile of changedFiles) {
+      changedFilesSet.add(changedFile);
+      deletedFilesSet.delete(changedFile);
+    }
+    for (const deletedFile of deletedFiles) {
+      changedFilesSet.delete(deletedFile);
+      deletedFilesSet.add(deletedFile);
+    }
   }
 
   return {
-    changedFiles,
-    deletedFiles,
+    changedFiles: Array.from(changedFilesSet),
+    deletedFiles: Array.from(deletedFilesSet),
   };
 }
 
-export { FilesChange, getFilesChange, updateFilesChange, clearFilesChange, aggregateFilesChanges };
+export {
+  FilesChange,
+  getFilesChange,
+  consumeFilesChange,
+  updateFilesChange,
+  clearFilesChange,
+  aggregateFilesChanges,
+};
diff --git a/src/formatter/BasicFormatter.ts b/src/formatter/basic-formatter.ts
similarity index 82%
rename from src/formatter/BasicFormatter.ts
rename to src/formatter/basic-formatter.ts
index e8f84b46..d6472f5f 100644
--- a/src/formatter/BasicFormatter.ts
+++ b/src/formatter/basic-formatter.ts
@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 
-import type { Formatter } from './Formatter';
+import type { Formatter } from './formatter';
 
 function createBasicFormatter(): Formatter {
   return function basicFormatter(issue) {
diff --git a/src/formatter/CodeFrameFormatter.ts b/src/formatter/code-frame-formatter.ts
similarity index 89%
rename from src/formatter/CodeFrameFormatter.ts
rename to src/formatter/code-frame-formatter.ts
index 0c815ebb..f8e3e3d1 100644
--- a/src/formatter/CodeFrameFormatter.ts
+++ b/src/formatter/code-frame-formatter.ts
@@ -3,8 +3,8 @@ import os from 'os';
 import { codeFrameColumns } from '@babel/code-frame';
 import fs from 'fs-extra';
 
-import { createBasicFormatter } from './BasicFormatter';
-import type { Formatter } from './Formatter';
+import { createBasicFormatter } from './basic-formatter';
+import type { Formatter } from './formatter';
 import { BabelCodeFrameOptions } from './types/babel__code-frame';
 
 function createCodeFrameFormatter(options?: BabelCodeFrameOptions): Formatter {
diff --git a/src/formatter/FormatterConfiguration.ts b/src/formatter/formatter-config.ts
similarity index 56%
rename from src/formatter/FormatterConfiguration.ts
rename to src/formatter/formatter-config.ts
index 964d2cec..9fb99ce4 100644
--- a/src/formatter/FormatterConfiguration.ts
+++ b/src/formatter/formatter-config.ts
@@ -1,13 +1,11 @@
-import { createBasicFormatter } from './BasicFormatter';
-import { createCodeFrameFormatter } from './CodeFrameFormatter';
-import type { Formatter } from './Formatter';
-import type { CodeframeFormatterOptions, FormatterOptions } from './FormatterOptions';
+import { createBasicFormatter } from './basic-formatter';
+import { createCodeFrameFormatter } from './code-frame-formatter';
+import type { Formatter } from './formatter';
+import type { CodeframeFormatterOptions, FormatterOptions } from './formatter-options';
 
-type FormatterConfiguration = Formatter;
+type FormatterConfig = Formatter;
 
-function createFormatterConfiguration(
-  options: FormatterOptions | undefined
-): FormatterConfiguration {
+function createFormatterConfig(options: FormatterOptions | undefined): FormatterConfig {
   if (typeof options === 'function') {
     return options;
   }
@@ -23,11 +21,11 @@ function createFormatterConfiguration(
   }
 
   if (type === 'codeframe') {
-    const configuration =
+    const config =
       options && typeof options === 'object'
         ? (options as CodeframeFormatterOptions).options || {}
         : {};
-    return createCodeFrameFormatter(configuration);
+    return createCodeFrameFormatter(config);
   }
 
   throw new Error(
@@ -35,4 +33,4 @@ function createFormatterConfiguration(
   );
 }
 
-export { FormatterConfiguration, createFormatterConfiguration };
+export { FormatterConfig, createFormatterConfig };
diff --git a/src/formatter/FormatterOptions.ts b/src/formatter/formatter-options.ts
similarity index 91%
rename from src/formatter/FormatterOptions.ts
rename to src/formatter/formatter-options.ts
index f98db1e6..deb6e72c 100644
--- a/src/formatter/FormatterOptions.ts
+++ b/src/formatter/formatter-options.ts
@@ -1,4 +1,4 @@
-import type { Formatter } from './Formatter';
+import type { Formatter } from './formatter';
 import type { BabelCodeFrameOptions } from './types/babel__code-frame';
 
 type FormatterType = 'basic' | 'codeframe';
diff --git a/src/formatter/Formatter.ts b/src/formatter/formatter.ts
similarity index 100%
rename from src/formatter/Formatter.ts
rename to src/formatter/formatter.ts
diff --git a/src/formatter/index.ts b/src/formatter/index.ts
index d3967202..03701a6a 100644
--- a/src/formatter/index.ts
+++ b/src/formatter/index.ts
@@ -1,6 +1,6 @@
-export * from './Formatter';
-export * from './BasicFormatter';
-export * from './CodeFrameFormatter';
-export * from './WebpackFormatter';
-export * from './FormatterOptions';
-export * from './FormatterConfiguration';
+export * from './formatter';
+export * from './basic-formatter';
+export * from './code-frame-formatter';
+export * from './webpack-formatter';
+export * from './formatter-options';
+export * from './formatter-config';
diff --git a/src/formatter/WebpackFormatter.ts b/src/formatter/webpack-formatter.ts
similarity index 87%
rename from src/formatter/WebpackFormatter.ts
rename to src/formatter/webpack-formatter.ts
index 44c8e950..0d4dc488 100644
--- a/src/formatter/WebpackFormatter.ts
+++ b/src/formatter/webpack-formatter.ts
@@ -3,9 +3,9 @@ import os from 'os';
 import chalk from 'chalk';
 
 import { formatIssueLocation } from '../issue';
-import { relativeToContext } from '../utils/path/relativeToContext';
+import { relativeToContext } from '../utils/path/relative-to-context';
 
-import type { Formatter } from './Formatter';
+import type { Formatter } from './formatter';
 
 function createWebpackFormatter(formatter: Formatter): Formatter {
   // mimics webpack error formatter
diff --git a/src/hooks/interceptDoneToGetWebpackDevServerTap.ts b/src/hooks/intercept-done-to-get-dev-server-tap.ts
similarity index 51%
rename from src/hooks/interceptDoneToGetWebpackDevServerTap.ts
rename to src/hooks/intercept-done-to-get-dev-server-tap.ts
index 7f20d551..1291c863 100644
--- a/src/hooks/interceptDoneToGetWebpackDevServerTap.ts
+++ b/src/hooks/intercept-done-to-get-dev-server-tap.ts
@@ -1,12 +1,12 @@
 import type webpack from 'webpack';
 
-import type { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
-import type { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
 import { getInfrastructureLogger } from '../infrastructure-logger';
+import type { ForkTsCheckerWebpackPluginConfig } from '../plugin-config';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
 
-function interceptDoneToGetWebpackDevServerTap(
+function interceptDoneToGetDevServerTap(
   compiler: webpack.Compiler,
-  configuration: ForkTsCheckerWebpackPluginConfiguration,
+  config: ForkTsCheckerWebpackPluginConfig,
   state: ForkTsCheckerWebpackPluginState
 ) {
   const { debug } = getInfrastructureLogger(compiler);
@@ -14,11 +14,7 @@ function interceptDoneToGetWebpackDevServerTap(
   // inspired by https://github.com/ypresto/fork-ts-checker-async-overlay-webpack-plugin
   compiler.hooks.done.intercept({
     register: (tap) => {
-      if (
-        tap.name === 'webpack-dev-server' &&
-        tap.type === 'sync' &&
-        configuration.logger.devServer
-      ) {
+      if (tap.name === 'webpack-dev-server' && tap.type === 'sync' && config.logger.devServer) {
         debug('Intercepting webpack-dev-server tap.');
         state.webpackDevServerDoneTap = tap;
       }
@@ -27,4 +23,4 @@ function interceptDoneToGetWebpackDevServerTap(
   });
 }
 
-export { interceptDoneToGetWebpackDevServerTap };
+export { interceptDoneToGetDevServerTap };
diff --git a/src/hooks/tapAfterCompileToAddDependencies.ts b/src/hooks/tap-after-compile-to-add-dependencies.ts
similarity index 77%
rename from src/hooks/tapAfterCompileToAddDependencies.ts
rename to src/hooks/tap-after-compile-to-add-dependencies.ts
index 3b9af69f..0d013554 100644
--- a/src/hooks/tapAfterCompileToAddDependencies.ts
+++ b/src/hooks/tap-after-compile-to-add-dependencies.ts
@@ -1,12 +1,12 @@
 import type webpack from 'webpack';
 
-import type { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
-import type { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
 import { getInfrastructureLogger } from '../infrastructure-logger';
+import type { ForkTsCheckerWebpackPluginConfig } from '../plugin-config';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
 
 function tapAfterCompileToAddDependencies(
   compiler: webpack.Compiler,
-  configuration: ForkTsCheckerWebpackPluginConfiguration,
+  config: ForkTsCheckerWebpackPluginConfig,
   state: ForkTsCheckerWebpackPluginState
 ) {
   const { debug } = getInfrastructureLogger(compiler);
diff --git a/src/hooks/tapAfterCompileToGetIssues.ts b/src/hooks/tap-after-compile-to-get-issues.ts
similarity index 68%
rename from src/hooks/tapAfterCompileToGetIssues.ts
rename to src/hooks/tap-after-compile-to-get-issues.ts
index c3b07e28..6f8a3187 100644
--- a/src/hooks/tapAfterCompileToGetIssues.ts
+++ b/src/hooks/tap-after-compile-to-get-issues.ts
@@ -1,19 +1,18 @@
 import type webpack from 'webpack';
 
-import type { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
-import type { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
 import { getInfrastructureLogger } from '../infrastructure-logger';
 import type { Issue } from '../issue';
-import { IssueWebpackError } from '../issue/IssueWebpackError';
-
-import { getForkTsCheckerWebpackPluginHooks } from './pluginHooks';
+import { IssueWebpackError } from '../issue/issue-webpack-error';
+import type { ForkTsCheckerWebpackPluginConfig } from '../plugin-config';
+import { getPluginHooks } from '../plugin-hooks';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
 
 function tapAfterCompileToGetIssues(
   compiler: webpack.Compiler,
-  configuration: ForkTsCheckerWebpackPluginConfiguration,
+  config: ForkTsCheckerWebpackPluginConfig,
   state: ForkTsCheckerWebpackPluginState
 ) {
-  const hooks = getForkTsCheckerWebpackPluginHooks(compiler);
+  const hooks = getPluginHooks(compiler);
   const { debug } = getInfrastructureLogger(compiler);
 
   compiler.hooks.afterCompile.tapPromise('ForkTsCheckerWebpackPlugin', async (compilation) => {
@@ -39,13 +38,13 @@ function tapAfterCompileToGetIssues(
     }
 
     // filter list of issues by provided issue predicate
-    issues = issues.filter(configuration.issue.predicate);
+    issues = issues.filter(config.issue.predicate);
 
     // modify list of issues in the plugin hooks
     issues = hooks.issues.call(issues, compilation);
 
     issues.forEach((issue) => {
-      const error = new IssueWebpackError(configuration.formatter(issue), issue);
+      const error = new IssueWebpackError(config.formatter(issue), issue);
 
       if (issue.severity === 'warning') {
         compilation.warnings.push(error);
diff --git a/src/hooks/tapAfterEnvironmentToPatchWatching.ts b/src/hooks/tap-after-environment-to-patch-watching.ts
similarity index 78%
rename from src/hooks/tapAfterEnvironmentToPatchWatching.ts
rename to src/hooks/tap-after-environment-to-patch-watching.ts
index 06a68edd..ef5db7f6 100644
--- a/src/hooks/tapAfterEnvironmentToPatchWatching.ts
+++ b/src/hooks/tap-after-environment-to-patch-watching.ts
@@ -1,9 +1,9 @@
 import type webpack from 'webpack';
 
-import type { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
 import { getInfrastructureLogger } from '../infrastructure-logger';
-import { InclusiveNodeWatchFileSystem } from '../watch/InclusiveNodeWatchFileSystem';
-import type { WatchFileSystem } from '../watch/WatchFileSystem';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
+import { InclusiveNodeWatchFileSystem } from '../watch/inclusive-node-watch-file-system';
+import type { WatchFileSystem } from '../watch/watch-file-system';
 
 function tapAfterEnvironmentToPatchWatching(
   compiler: webpack.Compiler,
diff --git a/src/hooks/tapDoneToAsyncGetIssues.ts b/src/hooks/tap-done-to-async-get-issues.ts
similarity index 66%
rename from src/hooks/tapDoneToAsyncGetIssues.ts
rename to src/hooks/tap-done-to-async-get-issues.ts
index d226699b..8d738ea2 100644
--- a/src/hooks/tapDoneToAsyncGetIssues.ts
+++ b/src/hooks/tap-done-to-async-get-issues.ts
@@ -1,23 +1,22 @@
 import chalk from 'chalk';
 import type webpack from 'webpack';
 
-import type { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
-import type { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
-import { createWebpackFormatter } from '../formatter/WebpackFormatter';
+import { createWebpackFormatter } from '../formatter/webpack-formatter';
 import { getInfrastructureLogger } from '../infrastructure-logger';
 import type { Issue } from '../issue';
-import { IssueWebpackError } from '../issue/IssueWebpackError';
-import isPending from '../utils/async/isPending';
-import wait from '../utils/async/wait';
-
-import { getForkTsCheckerWebpackPluginHooks } from './pluginHooks';
+import { IssueWebpackError } from '../issue/issue-webpack-error';
+import type { ForkTsCheckerWebpackPluginConfig } from '../plugin-config';
+import { getPluginHooks } from '../plugin-hooks';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
+import { isPending } from '../utils/async/is-pending';
+import { wait } from '../utils/async/wait';
 
 function tapDoneToAsyncGetIssues(
   compiler: webpack.Compiler,
-  configuration: ForkTsCheckerWebpackPluginConfiguration,
+  config: ForkTsCheckerWebpackPluginConfig,
   state: ForkTsCheckerWebpackPluginState
 ) {
-  const hooks = getForkTsCheckerWebpackPluginHooks(compiler);
+  const hooks = getPluginHooks(compiler);
   const { log, debug } = getInfrastructureLogger(compiler);
 
   compiler.hooks.done.tap('ForkTsCheckerWebpackPlugin', async (stats) => {
@@ -32,7 +31,7 @@ function tapDoneToAsyncGetIssues(
     try {
       if (await isPending(issuesPromise)) {
         hooks.waiting.call(stats.compilation);
-        configuration.logger.issues.log(chalk.cyan('Issues checking in progress...'));
+        config.logger.issues.log(chalk.cyan('Issues checking in progress...'));
       } else {
         // wait 10ms to log issues after webpack stats
         await wait(10);
@@ -51,25 +50,25 @@ function tapDoneToAsyncGetIssues(
     }
 
     // filter list of issues by provided issue predicate
-    issues = issues.filter(configuration.issue.predicate);
+    issues = issues.filter(config.issue.predicate);
 
     // modify list of issues in the plugin hooks
     issues = hooks.issues.call(issues, stats.compilation);
 
-    const formatter = createWebpackFormatter(configuration.formatter);
+    const formatter = createWebpackFormatter(config.formatter);
 
     if (issues.length) {
       // follow webpack's approach - one process.write to stderr with all errors and warnings
-      configuration.logger.issues.error(issues.map((issue) => formatter(issue)).join('\n'));
+      config.logger.issues.error(issues.map((issue) => formatter(issue)).join('\n'));
     } else {
-      configuration.logger.issues.log(chalk.green('No issues found.'));
+      config.logger.issues.log(chalk.green('No issues found.'));
     }
 
     // report issues to webpack-dev-server, if it's listening
     // skip reporting if there are no issues, to avoid an extra hot reload
     if (issues.length && state.webpackDevServerDoneTap) {
       issues.forEach((issue) => {
-        const error = new IssueWebpackError(configuration.formatter(issue), issue);
+        const error = new IssueWebpackError(config.formatter(issue), issue);
 
         if (issue.severity === 'warning') {
           stats.compilation.warnings.push(error);
diff --git a/src/hooks/tapErrorToLogMessage.ts b/src/hooks/tap-error-to-log-message.ts
similarity index 68%
rename from src/hooks/tapErrorToLogMessage.ts
rename to src/hooks/tap-error-to-log-message.ts
index c914b026..37323230 100644
--- a/src/hooks/tapErrorToLogMessage.ts
+++ b/src/hooks/tap-error-to-log-message.ts
@@ -1,23 +1,22 @@
 import chalk from 'chalk';
 import type webpack from 'webpack';
 
-import type { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
-import { RpcExitError } from '../utils/rpc';
-
-import { getForkTsCheckerWebpackPluginHooks } from './pluginHooks';
+import type { ForkTsCheckerWebpackPluginConfig } from '../plugin-config';
+import { getPluginHooks } from '../plugin-hooks';
+import { RpcExitError } from '../rpc';
 
 function tapErrorToLogMessage(
   compiler: webpack.Compiler,
-  configuration: ForkTsCheckerWebpackPluginConfiguration
+  config: ForkTsCheckerWebpackPluginConfig
 ) {
-  const hooks = getForkTsCheckerWebpackPluginHooks(compiler);
+  const hooks = getPluginHooks(compiler);
 
   hooks.error.tap('ForkTsCheckerWebpackPlugin', (error) => {
-    configuration.logger.issues.error(String(error));
+    config.logger.issues.error(String(error));
 
     if (error instanceof RpcExitError) {
       if (error.signal === 'SIGINT') {
-        configuration.logger.issues.error(
+        config.logger.issues.error(
           chalk.red(
             'Issues checking service interrupted - If running in a docker container, this may be caused ' +
               "by the container running out of memory. If so, try increasing the container's memory limit " +
@@ -25,7 +24,7 @@ function tapErrorToLogMessage(
           )
         );
       } else {
-        configuration.logger.issues.error(
+        config.logger.issues.error(
           chalk.red(
             'Issues checking service aborted - probably out of memory. ' +
               'Check the `memoryLimit` option in the ForkTsCheckerWebpackPlugin configuration.\n' +
diff --git a/src/hooks/tapStartToRunWorkers.ts b/src/hooks/tap-start-to-run-workers.ts
similarity index 77%
rename from src/hooks/tapStartToRunWorkers.ts
rename to src/hooks/tap-start-to-run-workers.ts
index a26f111d..6231119f 100644
--- a/src/hooks/tapStartToRunWorkers.ts
+++ b/src/hooks/tap-start-to-run-workers.ts
@@ -1,28 +1,28 @@
 import type * as webpack from 'webpack';
 
 import type { FilesChange } from '../files-change';
-import { getFilesChange } from '../files-change';
-import type { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
-import type { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
+import { consumeFilesChange } from '../files-change';
 import { getInfrastructureLogger } from '../infrastructure-logger';
+import type { ForkTsCheckerWebpackPluginConfig } from '../plugin-config';
+import { getPluginHooks } from '../plugin-hooks';
+import { dependenciesPool, issuesPool } from '../plugin-pools';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
+import type { RpcWorker } from '../rpc';
 import type { GetDependenciesWorker } from '../typescript/worker/get-dependencies-worker';
 import type { GetIssuesWorker } from '../typescript/worker/get-issues-worker';
-import type { RpcWorker } from '../utils/rpc';
 
-import { interceptDoneToGetWebpackDevServerTap } from './interceptDoneToGetWebpackDevServerTap';
-import { getForkTsCheckerWebpackPluginHooks } from './pluginHooks';
-import { dependenciesPool, issuesPool } from './pluginPools';
-import { tapAfterCompileToGetIssues } from './tapAfterCompileToGetIssues';
-import { tapDoneToAsyncGetIssues } from './tapDoneToAsyncGetIssues';
+import { interceptDoneToGetDevServerTap } from './intercept-done-to-get-dev-server-tap';
+import { tapAfterCompileToGetIssues } from './tap-after-compile-to-get-issues';
+import { tapDoneToAsyncGetIssues } from './tap-done-to-async-get-issues';
 
 function tapStartToRunWorkers(
   compiler: webpack.Compiler,
   getIssuesWorker: RpcWorker<GetIssuesWorker>,
   getDependenciesWorker: RpcWorker<GetDependenciesWorker>,
-  config: ForkTsCheckerWebpackPluginConfiguration,
+  config: ForkTsCheckerWebpackPluginConfig,
   state: ForkTsCheckerWebpackPluginState
 ) {
-  const hooks = getForkTsCheckerWebpackPluginHooks(compiler);
+  const hooks = getPluginHooks(compiler);
   const { log, debug } = getInfrastructureLogger(compiler);
 
   compiler.hooks.run.tap('ForkTsCheckerWebpackPlugin', () => {
@@ -44,7 +44,7 @@ function tapStartToRunWorkers(
         debug('Initializing plugin for watch run (async).');
 
         tapDoneToAsyncGetIssues(compiler, config, state);
-        interceptDoneToGetWebpackDevServerTap(compiler, config, state);
+        interceptDoneToGetDevServerTap(compiler, config, state);
       } else {
         debug('Initializing plugin for watch run (not async).');
 
@@ -64,7 +64,7 @@ function tapStartToRunWorkers(
     let change: FilesChange = {};
 
     if (state.watching) {
-      change = getFilesChange(compiler);
+      change = consumeFilesChange(compiler);
       log(
         [
           'Calling reporter service for incremental check.',
diff --git a/src/hooks/tapStopToTerminateWorkers.ts b/src/hooks/tap-stop-to-terminate-workers.ts
similarity index 86%
rename from src/hooks/tapStopToTerminateWorkers.ts
rename to src/hooks/tap-stop-to-terminate-workers.ts
index 39961ac9..0ed5b904 100644
--- a/src/hooks/tapStopToTerminateWorkers.ts
+++ b/src/hooks/tap-stop-to-terminate-workers.ts
@@ -1,8 +1,8 @@
 import type webpack from 'webpack';
 
-import type { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
 import { getInfrastructureLogger } from '../infrastructure-logger';
-import type { RpcWorker } from '../utils/rpc';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
+import type { RpcWorker } from '../rpc';
 
 function tapStopToTerminateWorkers(
   compiler: webpack.Compiler,
diff --git a/src/index.ts b/src/index.ts
index ffa67041..374dcec6 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,3 +1,3 @@
-import { ForkTsCheckerWebpackPlugin } from './ForkTsCheckerWebpackPlugin';
+import { ForkTsCheckerWebpackPlugin } from './plugin';
 
 export = ForkTsCheckerWebpackPlugin;
diff --git a/src/infrastructure-logger.ts b/src/infrastructure-logger.ts
index c9b3e688..6d7c0d96 100644
--- a/src/infrastructure-logger.ts
+++ b/src/infrastructure-logger.ts
@@ -1,6 +1,6 @@
 import type webpack from 'webpack';
 
-interface InfrastructureLogger {
+export interface InfrastructureLogger {
   log(...args: unknown[]): void;
   debug(...args: unknown[]): void;
   error(...args: unknown[]): void;
diff --git a/src/issue/index.ts b/src/issue/index.ts
index 30dd5102..24ce503d 100644
--- a/src/issue/index.ts
+++ b/src/issue/index.ts
@@ -1,3 +1,3 @@
-export * from './Issue';
-export * from './IssueSeverity';
-export * from './IssueLocation';
+export * from './issue';
+export * from './issue-severity';
+export * from './issue-location';
diff --git a/src/issue/IssueConfiguration.ts b/src/issue/issue-config.ts
similarity index 75%
rename from src/issue/IssueConfiguration.ts
rename to src/issue/issue-config.ts
index a69a18c9..fea3b0a7 100644
--- a/src/issue/IssueConfiguration.ts
+++ b/src/issue/issue-config.ts
@@ -1,11 +1,11 @@
 import type webpack from 'webpack';
 
-import { createIssuePredicateFromIssueMatch } from './IssueMatch';
-import type { IssuePredicateOption, IssueOptions } from './IssueOptions';
-import type { IssuePredicate } from './IssuePredicate';
-import { composeIssuePredicates, createTrivialIssuePredicate } from './IssuePredicate';
+import { createIssuePredicateFromIssueMatch } from './issue-match';
+import type { IssuePredicateOption, IssueOptions } from './issue-options';
+import type { IssuePredicate } from './issue-predicate';
+import { composeIssuePredicates, createTrivialIssuePredicate } from './issue-predicate';
 
-interface IssueConfiguration {
+interface IssueConfig {
   predicate: IssuePredicate;
 }
 
@@ -26,10 +26,10 @@ function createIssuePredicateFromOption(
     : createIssuePredicateFromIssueMatch(context, option);
 }
 
-function createIssueConfiguration(
+function createIssueConfig(
   compiler: webpack.Compiler,
   options: IssueOptions | undefined
-): IssueConfiguration {
+): IssueConfig {
   const context = compiler.options.context || process.cwd();
 
   if (!options) {
@@ -48,4 +48,4 @@ function createIssueConfiguration(
   };
 }
 
-export { IssueConfiguration, createIssueConfiguration };
+export { IssueConfig, createIssueConfig };
diff --git a/src/issue/IssueLocation.ts b/src/issue/issue-location.ts
similarity index 89%
rename from src/issue/IssueLocation.ts
rename to src/issue/issue-location.ts
index 186da7d3..1095eed5 100644
--- a/src/issue/IssueLocation.ts
+++ b/src/issue/issue-location.ts
@@ -1,5 +1,5 @@
-import type { IssuePosition } from './IssuePosition';
-import { compareIssuePositions } from './IssuePosition';
+import type { IssuePosition } from './issue-position';
+import { compareIssuePositions } from './issue-position';
 
 interface IssueLocation {
   start: IssuePosition;
diff --git a/src/issue/IssueMatch.ts b/src/issue/issue-match.ts
similarity index 86%
rename from src/issue/IssueMatch.ts
rename to src/issue/issue-match.ts
index 8046b64d..d90e76c7 100644
--- a/src/issue/IssueMatch.ts
+++ b/src/issue/issue-match.ts
@@ -2,9 +2,9 @@ import path from 'path';
 
 import minimatch from 'minimatch';
 
-import forwardSlash from '../utils/path/forwardSlash';
+import { forwardSlash } from '../utils/path/forward-slash';
 
-import type { IssuePredicate } from './IssuePredicate';
+import type { IssuePredicate } from './issue-predicate';
 
 import type { Issue } from './index';
 
diff --git a/src/issue/IssueOptions.ts b/src/issue/issue-options.ts
similarity index 69%
rename from src/issue/IssueOptions.ts
rename to src/issue/issue-options.ts
index 05485929..203c3ac6 100644
--- a/src/issue/IssueOptions.ts
+++ b/src/issue/issue-options.ts
@@ -1,5 +1,5 @@
-import type { IssueMatch } from './IssueMatch';
-import type { IssuePredicate } from './IssuePredicate';
+import type { IssueMatch } from './issue-match';
+import type { IssuePredicate } from './issue-predicate';
 
 type IssuePredicateOption = IssuePredicate | IssueMatch | (IssuePredicate | IssueMatch)[];
 
diff --git a/src/issue/IssuePosition.ts b/src/issue/issue-position.ts
similarity index 100%
rename from src/issue/IssuePosition.ts
rename to src/issue/issue-position.ts
diff --git a/src/issue/IssuePredicate.ts b/src/issue/issue-predicate.ts
similarity index 100%
rename from src/issue/IssuePredicate.ts
rename to src/issue/issue-predicate.ts
diff --git a/src/issue/IssueSeverity.ts b/src/issue/issue-severity.ts
similarity index 100%
rename from src/issue/IssueSeverity.ts
rename to src/issue/issue-severity.ts
diff --git a/src/issue/IssueWebpackError.ts b/src/issue/issue-webpack-error.ts
similarity index 82%
rename from src/issue/IssueWebpackError.ts
rename to src/issue/issue-webpack-error.ts
index 41b1ac62..a1f768dc 100644
--- a/src/issue/IssueWebpackError.ts
+++ b/src/issue/issue-webpack-error.ts
@@ -1,10 +1,10 @@
 import chalk from 'chalk';
 import webpack from 'webpack';
 
-import { relativeToContext } from '../utils/path/relativeToContext';
+import { relativeToContext } from '../utils/path/relative-to-context';
 
-import type { Issue } from './Issue';
-import { formatIssueLocation } from './IssueLocation';
+import type { Issue } from './issue';
+import { formatIssueLocation } from './issue-location';
 
 class IssueWebpackError extends webpack.WebpackError {
   readonly hideStack = true;
diff --git a/src/issue/Issue.ts b/src/issue/issue.ts
similarity index 85%
rename from src/issue/Issue.ts
rename to src/issue/issue.ts
index f556139a..1c14e3f9 100644
--- a/src/issue/Issue.ts
+++ b/src/issue/issue.ts
@@ -1,7 +1,7 @@
-import type { IssueLocation } from './IssueLocation';
-import { compareIssueLocations } from './IssueLocation';
-import type { IssueSeverity } from './IssueSeverity';
-import { compareIssueSeverities, isIssueSeverity } from './IssueSeverity';
+import type { IssueLocation } from './issue-location';
+import { compareIssueLocations } from './issue-location';
+import type { IssueSeverity } from './issue-severity';
+import { compareIssueSeverities, isIssueSeverity } from './issue-severity';
 
 interface Issue {
   severity: IssueSeverity;
diff --git a/src/logger/LoggerConfiguration.ts b/src/logger/logger-config.ts
similarity index 60%
rename from src/logger/LoggerConfiguration.ts
rename to src/logger/logger-config.ts
index 6688a2fc..6847a226 100644
--- a/src/logger/LoggerConfiguration.ts
+++ b/src/logger/logger-config.ts
@@ -1,19 +1,19 @@
 import type webpack from 'webpack';
 
-import type Logger from './Logger';
-import { createLogger } from './LoggerFactory';
-import type LoggerOptions from './LoggerOptions';
+import type Logger from './logger';
+import { createLogger } from './logger-factory';
+import type LoggerOptions from './logger-options';
 
-interface LoggerConfiguration {
+interface LoggerConfig {
   infrastructure: Logger;
   issues: Logger;
   devServer: boolean;
 }
 
-function createLoggerConfiguration(
+function createLoggerConfig(
   compiler: webpack.Compiler,
   options: LoggerOptions | undefined
-): LoggerConfiguration {
+): LoggerConfig {
   return {
     infrastructure: createLogger(
       (options && options.infrastructure) || 'webpack-infrastructure',
@@ -24,4 +24,4 @@ function createLoggerConfiguration(
   };
 }
 
-export { LoggerConfiguration, createLoggerConfiguration };
+export { LoggerConfig, createLoggerConfig };
diff --git a/src/logger/LoggerFactory.ts b/src/logger/logger-factory.ts
similarity index 77%
rename from src/logger/LoggerFactory.ts
rename to src/logger/logger-factory.ts
index 4ecfe2b5..972dd187 100644
--- a/src/logger/LoggerFactory.ts
+++ b/src/logger/logger-factory.ts
@@ -1,8 +1,8 @@
 import type webpack from 'webpack';
 
-import type Logger from './Logger';
-import { createPartialLogger } from './PartialLogger';
-import { createWebpackInfrastructureLogger } from './WebpackInfrastructureLogger';
+import type Logger from './logger';
+import { createPartialLogger } from './partial-logger';
+import { createWebpackInfrastructureLogger } from './webpack-infrastructure-logger';
 
 type LoggerType = 'console' | 'webpack-infrastructure' | 'silent';
 
diff --git a/src/logger/LoggerOptions.ts b/src/logger/logger-options.ts
similarity index 63%
rename from src/logger/LoggerOptions.ts
rename to src/logger/logger-options.ts
index bb8504f7..d0167563 100644
--- a/src/logger/LoggerOptions.ts
+++ b/src/logger/logger-options.ts
@@ -1,5 +1,5 @@
-import type Logger from './Logger';
-import type { LoggerType } from './LoggerFactory';
+import type Logger from './logger';
+import type { LoggerType } from './logger-factory';
 
 type LoggerOptions = {
   infrastructure?: LoggerType | Logger;
diff --git a/src/logger/Logger.ts b/src/logger/logger.ts
similarity index 100%
rename from src/logger/Logger.ts
rename to src/logger/logger.ts
diff --git a/src/logger/PartialLogger.ts b/src/logger/partial-logger.ts
similarity index 92%
rename from src/logger/PartialLogger.ts
rename to src/logger/partial-logger.ts
index e452ddeb..f62c0b5f 100644
--- a/src/logger/PartialLogger.ts
+++ b/src/logger/partial-logger.ts
@@ -1,4 +1,4 @@
-import type Logger from './Logger';
+import type Logger from './logger';
 
 type LoggerMethods = 'info' | 'log' | 'error';
 
diff --git a/src/logger/WebpackInfrastructureLogger.ts b/src/logger/webpack-infrastructure-logger.ts
similarity index 94%
rename from src/logger/WebpackInfrastructureLogger.ts
rename to src/logger/webpack-infrastructure-logger.ts
index 658d7b49..5a37a803 100644
--- a/src/logger/WebpackInfrastructureLogger.ts
+++ b/src/logger/webpack-infrastructure-logger.ts
@@ -1,6 +1,6 @@
 import type webpack from 'webpack';
 
-import type Logger from './Logger';
+import type Logger from './logger';
 
 interface InfrastructureLoggerProvider {
   getInfrastructureLogger(name: string): Logger;
diff --git a/src/plugin-config.ts b/src/plugin-config.ts
new file mode 100644
index 00000000..109066a1
--- /dev/null
+++ b/src/plugin-config.ts
@@ -0,0 +1,34 @@
+import type webpack from 'webpack';
+
+import type { FormatterConfig } from './formatter';
+import { createFormatterConfig } from './formatter';
+import type { IssueConfig } from './issue/issue-config';
+import { createIssueConfig } from './issue/issue-config';
+import type { LoggerConfig } from './logger/logger-config';
+import { createLoggerConfig } from './logger/logger-config';
+import type { ForkTsCheckerWebpackPluginOptions } from './plugin-options';
+import type { TypeScriptWorkerConfig } from './typescript/type-script-worker-config';
+import { createTypeScriptWorkerConfig } from './typescript/type-script-worker-config';
+
+interface ForkTsCheckerWebpackPluginConfig {
+  async: boolean;
+  typescript: TypeScriptWorkerConfig;
+  issue: IssueConfig;
+  formatter: FormatterConfig;
+  logger: LoggerConfig;
+}
+
+function createPluginConfig(
+  compiler: webpack.Compiler,
+  options: ForkTsCheckerWebpackPluginOptions = {}
+): ForkTsCheckerWebpackPluginConfig {
+  return {
+    async: options.async === undefined ? compiler.options.mode === 'development' : options.async,
+    typescript: createTypeScriptWorkerConfig(compiler, options.typescript),
+    issue: createIssueConfig(compiler, options.issue),
+    formatter: createFormatterConfig(options.formatter),
+    logger: createLoggerConfig(compiler, options.logger),
+  };
+}
+
+export { ForkTsCheckerWebpackPluginConfig, createPluginConfig };
diff --git a/src/hooks/pluginHooks.ts b/src/plugin-hooks.ts
similarity index 69%
rename from src/hooks/pluginHooks.ts
rename to src/plugin-hooks.ts
index 865d7dbf..bb2e1925 100644
--- a/src/hooks/pluginHooks.ts
+++ b/src/plugin-hooks.ts
@@ -1,15 +1,15 @@
 import { SyncHook, SyncWaterfallHook, AsyncSeriesWaterfallHook } from 'tapable';
 import type * as webpack from 'webpack';
 
-import type { FilesChange } from '../files-change';
-import type { Issue } from '../issue';
+import type { FilesChange } from './files-change';
+import type { Issue } from './issue';
 
 const compilerHookMap = new WeakMap<
   webpack.Compiler | webpack.MultiCompiler,
   ForkTsCheckerWebpackPluginHooks
 >();
 
-function createForkTsCheckerWebpackPluginHooks() {
+function createPluginHooks() {
   return {
     start: new AsyncSeriesWaterfallHook<[FilesChange, webpack.Compilation]>([
       'change',
@@ -25,9 +25,9 @@ function createForkTsCheckerWebpackPluginHooks() {
   };
 }
 
-type ForkTsCheckerWebpackPluginHooks = ReturnType<typeof createForkTsCheckerWebpackPluginHooks>;
+type ForkTsCheckerWebpackPluginHooks = ReturnType<typeof createPluginHooks>;
 
-function forwardForkTsCheckerWebpackPluginHooks(
+function forwardPluginHooks(
   source: ForkTsCheckerWebpackPluginHooks,
   target: ForkTsCheckerWebpackPluginHooks
 ) {
@@ -38,19 +38,19 @@ function forwardForkTsCheckerWebpackPluginHooks(
   source.issues.tap('ForkTsCheckerWebpackPlugin', target.issues.call);
 }
 
-function getForkTsCheckerWebpackPluginHooks(compiler: webpack.Compiler | webpack.MultiCompiler) {
+function getPluginHooks(compiler: webpack.Compiler | webpack.MultiCompiler) {
   let hooks = compilerHookMap.get(compiler);
   if (hooks === undefined) {
-    hooks = createForkTsCheckerWebpackPluginHooks();
+    hooks = createPluginHooks();
     compilerHookMap.set(compiler, hooks);
 
     // proxy hooks for multi-compiler
     if ('compilers' in compiler) {
       compiler.compilers.forEach((childCompiler) => {
-        const childHooks = getForkTsCheckerWebpackPluginHooks(childCompiler);
+        const childHooks = getPluginHooks(childCompiler);
 
         if (hooks) {
-          forwardForkTsCheckerWebpackPluginHooks(childHooks, hooks);
+          forwardPluginHooks(childHooks, hooks);
         }
       });
     }
@@ -58,4 +58,4 @@ function getForkTsCheckerWebpackPluginHooks(compiler: webpack.Compiler | webpack
   return hooks;
 }
 
-export { getForkTsCheckerWebpackPluginHooks, ForkTsCheckerWebpackPluginHooks };
+export { getPluginHooks, ForkTsCheckerWebpackPluginHooks };
diff --git a/src/ForkTsCheckerWebpackPluginOptions.json b/src/plugin-options.json
similarity index 100%
rename from src/ForkTsCheckerWebpackPluginOptions.json
rename to src/plugin-options.json
diff --git a/src/ForkTsCheckerWebpackPluginOptions.ts b/src/plugin-options.ts
similarity index 50%
rename from src/ForkTsCheckerWebpackPluginOptions.ts
rename to src/plugin-options.ts
index 06b8a2f7..7e7f24f4 100644
--- a/src/ForkTsCheckerWebpackPluginOptions.ts
+++ b/src/plugin-options.ts
@@ -1,11 +1,11 @@
 import type { FormatterOptions } from './formatter';
-import type { IssueOptions } from './issue/IssueOptions';
-import type LoggerOptions from './logger/LoggerOptions';
-import type { TypeScriptReporterOptions } from './typescript/TypeScriptReporterOptions';
+import type { IssueOptions } from './issue/issue-options';
+import type LoggerOptions from './logger/logger-options';
+import type { TypeScriptWorkerOptions } from './typescript/type-script-worker-options';
 
 interface ForkTsCheckerWebpackPluginOptions {
   async?: boolean;
-  typescript?: TypeScriptReporterOptions;
+  typescript?: TypeScriptWorkerOptions;
   formatter?: FormatterOptions;
   issue?: IssueOptions;
   logger?: LoggerOptions;
diff --git a/src/hooks/pluginPools.ts b/src/plugin-pools.ts
similarity index 68%
rename from src/hooks/pluginPools.ts
rename to src/plugin-pools.ts
index 4e554819..de17bb0f 100644
--- a/src/hooks/pluginPools.ts
+++ b/src/plugin-pools.ts
@@ -1,7 +1,7 @@
 import * as os from 'os';
 
-import type { Pool } from '../utils/async/pool';
-import { createPool } from '../utils/async/pool';
+import type { Pool } from './utils/async/pool';
+import { createPool } from './utils/async/pool';
 
 const issuesPool: Pool = createPool(Math.max(1, os.cpus().length));
 const dependenciesPool: Pool = createPool(Math.max(1, os.cpus().length));
diff --git a/src/ForkTsCheckerWebpackPluginState.ts b/src/plugin-state.ts
similarity index 80%
rename from src/ForkTsCheckerWebpackPluginState.ts
rename to src/plugin-state.ts
index 3153164d..7a8aa840 100644
--- a/src/ForkTsCheckerWebpackPluginState.ts
+++ b/src/plugin-state.ts
@@ -13,7 +13,7 @@ interface ForkTsCheckerWebpackPluginState {
   webpackDevServerDoneTap: FullTap | undefined;
 }
 
-function createForkTsCheckerWebpackPluginState(): ForkTsCheckerWebpackPluginState {
+function createPluginState(): ForkTsCheckerWebpackPluginState {
   return {
     issuesPromise: Promise.resolve(undefined),
     dependenciesPromise: Promise.resolve(undefined),
@@ -25,4 +25,4 @@ function createForkTsCheckerWebpackPluginState(): ForkTsCheckerWebpackPluginStat
   };
 }
 
-export { ForkTsCheckerWebpackPluginState, createForkTsCheckerWebpackPluginState };
+export { ForkTsCheckerWebpackPluginState, createPluginState };
diff --git a/src/ForkTsCheckerWebpackPlugin.ts b/src/plugin.ts
similarity index 51%
rename from src/ForkTsCheckerWebpackPlugin.ts
rename to src/plugin.ts
index e5c8b5ee..880cc6a9 100644
--- a/src/ForkTsCheckerWebpackPlugin.ts
+++ b/src/plugin.ts
@@ -5,24 +5,22 @@ import merge from 'deepmerge';
 import type { JSONSchema7 } from 'json-schema';
 import { validate } from 'schema-utils';
 import type webpack from 'webpack';
-// type only dependency
-// eslint-disable-next-line node/no-extraneous-import
 
-import { createForkTsCheckerWebpackPluginConfiguration } from './ForkTsCheckerWebpackPluginConfiguration';
-import type { ForkTsCheckerWebpackPluginOptions } from './ForkTsCheckerWebpackPluginOptions';
-import schema from './ForkTsCheckerWebpackPluginOptions.json';
-import { createForkTsCheckerWebpackPluginState } from './ForkTsCheckerWebpackPluginState';
-import { getForkTsCheckerWebpackPluginHooks } from './hooks/pluginHooks';
-import { dependenciesPool, issuesPool } from './hooks/pluginPools';
-import { tapAfterCompileToAddDependencies } from './hooks/tapAfterCompileToAddDependencies';
-import { tapAfterEnvironmentToPatchWatching } from './hooks/tapAfterEnvironmentToPatchWatching';
-import { tapErrorToLogMessage } from './hooks/tapErrorToLogMessage';
-import { tapStartToRunWorkers } from './hooks/tapStartToRunWorkers';
-import { tapStopToTerminateWorkers } from './hooks/tapStopToTerminateWorkers';
-import { assertTypeScriptSupport } from './typescript/TypeScriptSupport';
+import { tapAfterCompileToAddDependencies } from './hooks/tap-after-compile-to-add-dependencies';
+import { tapAfterEnvironmentToPatchWatching } from './hooks/tap-after-environment-to-patch-watching';
+import { tapErrorToLogMessage } from './hooks/tap-error-to-log-message';
+import { tapStartToRunWorkers } from './hooks/tap-start-to-run-workers';
+import { tapStopToTerminateWorkers } from './hooks/tap-stop-to-terminate-workers';
+import { createPluginConfig } from './plugin-config';
+import { getPluginHooks } from './plugin-hooks';
+import type { ForkTsCheckerWebpackPluginOptions } from './plugin-options';
+import schema from './plugin-options.json';
+import { dependenciesPool, issuesPool } from './plugin-pools';
+import { createPluginState } from './plugin-state';
+import { createRpcWorker } from './rpc';
+import { assertTypeScriptSupport } from './typescript/type-script-support';
 import type { GetDependenciesWorker } from './typescript/worker/get-dependencies-worker';
 import type { GetIssuesWorker } from './typescript/worker/get-issues-worker';
-import { createRpcWorker } from './utils/rpc';
 
 class ForkTsCheckerWebpackPlugin {
   /**
@@ -47,39 +45,39 @@ class ForkTsCheckerWebpackPlugin {
     const { config: externalOptions } = explorerSync.search() || {};
 
     // first validate options directly passed to the constructor
-    const configuration = { name: 'ForkTsCheckerWebpackPlugin' };
-    validate(schema as JSONSchema7, options, configuration);
+    const config = { name: 'ForkTsCheckerWebpackPlugin' };
+    validate(schema as JSONSchema7, options, config);
 
     this.options = merge(externalOptions || {}, options || {});
 
     // then validate merged options
-    validate(schema as JSONSchema7, this.options, configuration);
+    validate(schema as JSONSchema7, this.options, config);
   }
 
   public static getCompilerHooks(compiler: webpack.Compiler) {
-    return getForkTsCheckerWebpackPluginHooks(compiler);
+    return getPluginHooks(compiler);
   }
 
   apply(compiler: webpack.Compiler) {
-    const configuration = createForkTsCheckerWebpackPluginConfiguration(compiler, this.options);
-    const state = createForkTsCheckerWebpackPluginState();
+    const config = createPluginConfig(compiler, this.options);
+    const state = createPluginState();
 
-    assertTypeScriptSupport(configuration.typescript);
+    assertTypeScriptSupport(config.typescript);
     const getIssuesWorker = createRpcWorker<GetIssuesWorker>(
       path.resolve(__dirname, './typescript/worker/get-issues-worker.js'),
-      configuration.typescript,
-      configuration.typescript.memoryLimit
+      config.typescript,
+      config.typescript.memoryLimit
     );
     const getDependenciesWorker = createRpcWorker<GetDependenciesWorker>(
       path.resolve(__dirname, './typescript/worker/get-dependencies-worker.js'),
-      configuration.typescript
+      config.typescript
     );
 
     tapAfterEnvironmentToPatchWatching(compiler, state);
-    tapStartToRunWorkers(compiler, getIssuesWorker, getDependenciesWorker, configuration, state);
-    tapAfterCompileToAddDependencies(compiler, configuration, state);
+    tapStartToRunWorkers(compiler, getIssuesWorker, getDependenciesWorker, config, state);
+    tapAfterCompileToAddDependencies(compiler, config, state);
     tapStopToTerminateWorkers(compiler, getIssuesWorker, getDependenciesWorker, state);
-    tapErrorToLogMessage(compiler, configuration);
+    tapErrorToLogMessage(compiler, config);
   }
 }
 
diff --git a/src/utils/rpc/expose.ts b/src/rpc/expose-rpc.ts
similarity index 100%
rename from src/utils/rpc/expose.ts
rename to src/rpc/expose-rpc.ts
diff --git a/src/rpc/index.ts b/src/rpc/index.ts
new file mode 100644
index 00000000..d5081fd4
--- /dev/null
+++ b/src/rpc/index.ts
@@ -0,0 +1,5 @@
+export { exposeRpc } from './expose-rpc';
+export { wrapRpc } from './wrap-rpc';
+export { createRpcWorker, getRpcWorkerData, RpcWorker } from './rpc-worker';
+export { RpcExitError } from './rpc-error';
+export { RpcRemoteMethod } from './types';
diff --git a/src/utils/rpc/error.ts b/src/rpc/rpc-error.ts
similarity index 100%
rename from src/utils/rpc/error.ts
rename to src/rpc/rpc-error.ts
diff --git a/src/utils/rpc/worker.ts b/src/rpc/rpc-worker.ts
similarity index 98%
rename from src/utils/rpc/worker.ts
rename to src/rpc/rpc-worker.ts
index c32934d4..e975ffd6 100644
--- a/src/utils/rpc/worker.ts
+++ b/src/rpc/rpc-worker.ts
@@ -3,7 +3,7 @@ import type { ChildProcess, ForkOptions } from 'child_process';
 import * as process from 'process';
 
 import type { RpcMethod, RpcRemoteMethod } from './types';
-import { wrapRpc } from './wrap';
+import { wrapRpc } from './wrap-rpc';
 
 const WORKER_DATA_ENV_KEY = 'WORKER_DATA';
 
diff --git a/src/utils/rpc/types.ts b/src/rpc/types.ts
similarity index 100%
rename from src/utils/rpc/types.ts
rename to src/rpc/types.ts
diff --git a/src/utils/rpc/wrap.ts b/src/rpc/wrap-rpc.ts
similarity index 98%
rename from src/utils/rpc/wrap.ts
rename to src/rpc/wrap-rpc.ts
index 85c5980d..759b0559 100644
--- a/src/utils/rpc/wrap.ts
+++ b/src/rpc/wrap-rpc.ts
@@ -1,7 +1,7 @@
 import type { ChildProcess } from 'child_process';
 import * as process from 'process';
 
-import { RpcExitError } from './error';
+import { RpcExitError } from './rpc-error';
 import type { RpcRemoteMethod, RpcMessage } from './types';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
diff --git a/src/typescript/extension/TypeScriptEmbeddedExtension.ts b/src/typescript/extension/type-script-embedded-extension.ts
similarity index 98%
rename from src/typescript/extension/TypeScriptEmbeddedExtension.ts
rename to src/typescript/extension/type-script-embedded-extension.ts
index 753a900f..02f6d454 100644
--- a/src/typescript/extension/TypeScriptEmbeddedExtension.ts
+++ b/src/typescript/extension/type-script-embedded-extension.ts
@@ -5,7 +5,7 @@ import type * as ts from 'typescript';
 import type { FilesMatch } from '../../files-match';
 import type { Issue } from '../../issue';
 
-import type { TypeScriptExtension } from './TypeScriptExtension';
+import type { TypeScriptExtension } from './type-script-extension';
 
 interface TypeScriptEmbeddedSource {
   sourceText: string;
diff --git a/src/typescript/extension/TypeScriptExtension.ts b/src/typescript/extension/type-script-extension.ts
similarity index 100%
rename from src/typescript/extension/TypeScriptExtension.ts
rename to src/typescript/extension/type-script-extension.ts
diff --git a/src/typescript/extension/vue/TypeScriptVueExtensionConfiguration.ts b/src/typescript/extension/vue/TypeScriptVueExtensionConfiguration.ts
deleted file mode 100644
index 861f8778..00000000
--- a/src/typescript/extension/vue/TypeScriptVueExtensionConfiguration.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { TypeScriptVueExtensionOptions } from './TypeScriptVueExtensionOptions';
-
-interface TypeScriptVueExtensionConfiguration {
-  enabled: boolean;
-  compiler: string;
-}
-
-function createTypeScriptVueExtensionConfiguration(
-  options: TypeScriptVueExtensionOptions | undefined
-): TypeScriptVueExtensionConfiguration {
-  return {
-    enabled: options === true,
-    compiler: 'vue-template-compiler',
-    ...(typeof options === 'object' ? options : {}),
-  };
-}
-
-export { TypeScriptVueExtensionConfiguration, createTypeScriptVueExtensionConfiguration };
diff --git a/src/typescript/extension/vue/type-script-vue-extension-config.ts b/src/typescript/extension/vue/type-script-vue-extension-config.ts
new file mode 100644
index 00000000..b0027f1e
--- /dev/null
+++ b/src/typescript/extension/vue/type-script-vue-extension-config.ts
@@ -0,0 +1,18 @@
+import type { TypeScriptVueExtensionOptions } from './type-script-vue-extension-options';
+
+interface TypeScriptVueExtensionConfig {
+  enabled: boolean;
+  compiler: string;
+}
+
+function createTypeScriptVueExtensionConfig(
+  options: TypeScriptVueExtensionOptions | undefined
+): TypeScriptVueExtensionConfig {
+  return {
+    enabled: options === true,
+    compiler: 'vue-template-compiler',
+    ...(typeof options === 'object' ? options : {}),
+  };
+}
+
+export { TypeScriptVueExtensionConfig, createTypeScriptVueExtensionConfig };
diff --git a/src/typescript/extension/vue/TypeScriptVueExtensionOptions.ts b/src/typescript/extension/vue/type-script-vue-extension-options.ts
similarity index 100%
rename from src/typescript/extension/vue/TypeScriptVueExtensionOptions.ts
rename to src/typescript/extension/vue/type-script-vue-extension-options.ts
diff --git a/src/typescript/extension/vue/TypeScriptVueExtensionSupport.ts b/src/typescript/extension/vue/type-script-vue-extension-support.ts
similarity index 74%
rename from src/typescript/extension/vue/TypeScriptVueExtensionSupport.ts
rename to src/typescript/extension/vue/type-script-vue-extension-support.ts
index c21a245d..51bc75b6 100644
--- a/src/typescript/extension/vue/TypeScriptVueExtensionSupport.ts
+++ b/src/typescript/extension/vue/type-script-vue-extension-support.ts
@@ -1,11 +1,11 @@
-import type { TypeScriptVueExtensionConfiguration } from './TypeScriptVueExtensionConfiguration';
+import type { TypeScriptVueExtensionConfig } from './type-script-vue-extension-config';
 
-function assertTypeScriptVueExtensionSupport(configuration: TypeScriptVueExtensionConfiguration) {
+function assertTypeScriptVueExtensionSupport(config: TypeScriptVueExtensionConfig) {
   // We need to import template compiler for vue lazily because it cannot be included it
   // as direct dependency because it is an optional dependency of fork-ts-checker-webpack-plugin.
   // Since its version must not mismatch with user-installed Vue.js,
   // we should let the users install template compiler for vue by themselves.
-  const compilerName = configuration.compiler;
+  const compilerName = config.compiler;
 
   try {
     require(compilerName);
diff --git a/src/typescript/extension/vue/TypeScriptVueExtension.ts b/src/typescript/extension/vue/type-script-vue-extension.ts
similarity index 89%
rename from src/typescript/extension/vue/TypeScriptVueExtension.ts
rename to src/typescript/extension/vue/type-script-vue-extension.ts
index 7f79a194..3ef1353e 100644
--- a/src/typescript/extension/vue/TypeScriptVueExtension.ts
+++ b/src/typescript/extension/vue/type-script-vue-extension.ts
@@ -1,12 +1,12 @@
 import fs from 'fs-extra';
 
-import type { TypeScriptEmbeddedSource } from '../TypeScriptEmbeddedExtension';
-import { createTypeScriptEmbeddedExtension } from '../TypeScriptEmbeddedExtension';
-import type { TypeScriptExtension } from '../TypeScriptExtension';
+import type { TypeScriptEmbeddedSource } from '../type-script-embedded-extension';
+import { createTypeScriptEmbeddedExtension } from '../type-script-embedded-extension';
+import type { TypeScriptExtension } from '../type-script-extension';
 
+import type { TypeScriptVueExtensionConfig } from './type-script-vue-extension-config';
 import type { VueTemplateCompilerV2 } from './types/vue-template-compiler';
 import type { VueTemplateCompilerV3 } from './types/vue__compiler-sfc';
-import type { TypeScriptVueExtensionConfiguration } from './TypeScriptVueExtensionConfiguration';
 
 interface GenericScriptSFCBlock {
   content: string;
@@ -17,11 +17,9 @@ interface GenericScriptSFCBlock {
   src?: string;
 }
 
-function createTypeScriptVueExtension(
-  configuration: TypeScriptVueExtensionConfiguration
-): TypeScriptExtension {
+function createTypeScriptVueExtension(config: TypeScriptVueExtensionConfig): TypeScriptExtension {
   function loadVueTemplateCompiler(): VueTemplateCompilerV2 | VueTemplateCompilerV3 {
-    return require(configuration.compiler);
+    return require(config.compiler);
   }
 
   function isVueTemplateCompilerV2(
diff --git a/src/typescript/TypeScriptConfigurationOverwrite.ts b/src/typescript/type-script-config-overwrite.ts
similarity index 68%
rename from src/typescript/TypeScriptConfigurationOverwrite.ts
rename to src/typescript/type-script-config-overwrite.ts
index ba4d84cd..6fc4172c 100644
--- a/src/typescript/TypeScriptConfigurationOverwrite.ts
+++ b/src/typescript/type-script-config-overwrite.ts
@@ -1,4 +1,4 @@
-interface TypeScriptConfigurationOverwrite {
+interface TypeScriptConfigOverwrite {
   extends?: string;
   // eslint-disable-next-line
   compilerOptions?: any;
@@ -8,4 +8,4 @@ interface TypeScriptConfigurationOverwrite {
   references?: { path: string; prepend?: boolean }[];
 }
 
-export { TypeScriptConfigurationOverwrite };
+export { TypeScriptConfigOverwrite };
diff --git a/src/typescript/TypeScriptDiagnosticsOptions.ts b/src/typescript/type-script-diagnostics-options.ts
similarity index 100%
rename from src/typescript/TypeScriptDiagnosticsOptions.ts
rename to src/typescript/type-script-diagnostics-options.ts
diff --git a/src/typescript/TypeScriptSupport.ts b/src/typescript/type-script-support.ts
similarity index 71%
rename from src/typescript/TypeScriptSupport.ts
rename to src/typescript/type-script-support.ts
index 1da23276..5d75bd89 100644
--- a/src/typescript/TypeScriptSupport.ts
+++ b/src/typescript/type-script-support.ts
@@ -3,15 +3,15 @@ import os from 'os';
 import fs from 'fs-extra';
 import * as semver from 'semver';
 
-import { assertTypeScriptVueExtensionSupport } from './extension/vue/TypeScriptVueExtensionSupport';
-import type { TypeScriptReporterConfiguration } from './TypeScriptReporterConfiguration';
+import { assertTypeScriptVueExtensionSupport } from './extension/vue/type-script-vue-extension-support';
+import type { TypeScriptWorkerConfig } from './type-script-worker-config';
 
-function assertTypeScriptSupport(configuration: TypeScriptReporterConfiguration) {
+function assertTypeScriptSupport(config: TypeScriptWorkerConfig) {
   let typescriptVersion: string | undefined;
 
   try {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    typescriptVersion = require(configuration.typescriptPath).version;
+    typescriptVersion = require(config.typescriptPath).version;
   } catch (error) {
     // silent catch
   }
@@ -30,7 +30,7 @@ function assertTypeScriptSupport(configuration: TypeScriptReporterConfiguration)
       ].join(os.EOL)
     );
   }
-  if (configuration.build && semver.lt(typescriptVersion, '3.8.0')) {
+  if (config.build && semver.lt(typescriptVersion, '3.8.0')) {
     throw new Error(
       [
         `ForkTsCheckerWebpackPlugin doesn't support build option for the current typescript version of ${typescriptVersion}.`,
@@ -39,10 +39,10 @@ function assertTypeScriptSupport(configuration: TypeScriptReporterConfiguration)
     );
   }
 
-  if (!fs.existsSync(configuration.configFile)) {
+  if (!fs.existsSync(config.configFile)) {
     throw new Error(
       [
-        `Cannot find the "${configuration.configFile}" file.`,
+        `Cannot find the "${config.configFile}" file.`,
         `Please check webpack and ForkTsCheckerWebpackPlugin configuration.`,
         `Possible errors:`,
         '  - wrong `context` directory in webpack configuration (if `configFile` is not set or is a relative path in the fork plugin configuration)',
@@ -51,8 +51,8 @@ function assertTypeScriptSupport(configuration: TypeScriptReporterConfiguration)
     );
   }
 
-  if (configuration.extensions.vue.enabled) {
-    assertTypeScriptVueExtensionSupport(configuration.extensions.vue);
+  if (config.extensions.vue.enabled) {
+    assertTypeScriptVueExtensionSupport(config.extensions.vue);
   }
 }
 
diff --git a/src/typescript/TypeScriptReporterConfiguration.ts b/src/typescript/type-script-worker-config.ts
similarity index 68%
rename from src/typescript/TypeScriptReporterConfiguration.ts
rename to src/typescript/type-script-worker-config.ts
index ab0fe5c4..1c2ac79d 100644
--- a/src/typescript/TypeScriptReporterConfiguration.ts
+++ b/src/typescript/type-script-worker-config.ts
@@ -3,32 +3,32 @@ import path from 'path';
 import semver from 'semver';
 import type webpack from 'webpack';
 
-import type { TypeScriptVueExtensionConfiguration } from './extension/vue/TypeScriptVueExtensionConfiguration';
-import { createTypeScriptVueExtensionConfiguration } from './extension/vue/TypeScriptVueExtensionConfiguration';
-import type { TypeScriptConfigurationOverwrite } from './TypeScriptConfigurationOverwrite';
-import type { TypeScriptDiagnosticsOptions } from './TypeScriptDiagnosticsOptions';
-import type { TypeScriptReporterOptions } from './TypeScriptReporterOptions';
+import type { TypeScriptVueExtensionConfig } from './extension/vue/type-script-vue-extension-config';
+import { createTypeScriptVueExtensionConfig } from './extension/vue/type-script-vue-extension-config';
+import type { TypeScriptConfigOverwrite } from './type-script-config-overwrite';
+import type { TypeScriptDiagnosticsOptions } from './type-script-diagnostics-options';
+import type { TypeScriptWorkerOptions } from './type-script-worker-options';
 
-interface TypeScriptReporterConfiguration {
+interface TypeScriptWorkerConfig {
   enabled: boolean;
   memoryLimit: number;
   configFile: string;
-  configOverwrite: TypeScriptConfigurationOverwrite;
+  configOverwrite: TypeScriptConfigOverwrite;
   build: boolean;
   context: string;
   mode: 'readonly' | 'write-tsbuildinfo' | 'write-references';
   diagnosticOptions: TypeScriptDiagnosticsOptions;
   extensions: {
-    vue: TypeScriptVueExtensionConfiguration;
+    vue: TypeScriptVueExtensionConfig;
   };
   profile: boolean;
   typescriptPath: string;
 }
 
-function createTypeScriptReporterConfiguration(
+function createTypeScriptWorkerConfig(
   compiler: webpack.Compiler,
-  options: TypeScriptReporterOptions | undefined
-): TypeScriptReporterConfiguration {
+  options: TypeScriptWorkerOptions | undefined
+): TypeScriptWorkerConfig {
   let configFile =
     typeof options === 'object' ? options.configFile || 'tsconfig.json' : 'tsconfig.json';
 
@@ -39,7 +39,7 @@ function createTypeScriptReporterConfiguration(
       : path.resolve(compiler.options.context || process.cwd(), configFile)
   );
 
-  const optionsAsObject: Exclude<TypeScriptReporterOptions, boolean> =
+  const optionsAsObject: Exclude<TypeScriptWorkerOptions, boolean> =
     typeof options === 'object' ? options : {};
 
   const typescriptPath = optionsAsObject.typescriptPath || require.resolve('typescript');
@@ -71,7 +71,7 @@ function createTypeScriptReporterConfiguration(
     },
     context: optionsAsObject.context || path.dirname(configFile),
     extensions: {
-      vue: createTypeScriptVueExtensionConfiguration(
+      vue: createTypeScriptVueExtensionConfig(
         optionsAsObject.extensions ? optionsAsObject.extensions.vue : undefined
       ),
     },
@@ -86,4 +86,4 @@ function createTypeScriptReporterConfiguration(
   };
 }
 
-export { createTypeScriptReporterConfiguration, TypeScriptReporterConfiguration };
+export { createTypeScriptWorkerConfig, TypeScriptWorkerConfig };
diff --git a/src/typescript/TypeScriptReporterOptions.ts b/src/typescript/type-script-worker-options.ts
similarity index 53%
rename from src/typescript/TypeScriptReporterOptions.ts
rename to src/typescript/type-script-worker-options.ts
index 35e3fcdc..07afed2e 100644
--- a/src/typescript/TypeScriptReporterOptions.ts
+++ b/src/typescript/type-script-worker-options.ts
@@ -1,11 +1,11 @@
-import type { TypeScriptVueExtensionOptions } from './extension/vue/TypeScriptVueExtensionOptions';
-import type { TypeScriptConfigurationOverwrite } from './TypeScriptConfigurationOverwrite';
-import type { TypeScriptDiagnosticsOptions } from './TypeScriptDiagnosticsOptions';
+import type { TypeScriptVueExtensionOptions } from './extension/vue/type-script-vue-extension-options';
+import type { TypeScriptConfigOverwrite } from './type-script-config-overwrite';
+import type { TypeScriptDiagnosticsOptions } from './type-script-diagnostics-options';
 
-type TypeScriptReporterOptions = {
+type TypeScriptWorkerOptions = {
   memoryLimit?: number;
   configFile?: string;
-  configOverwrite?: TypeScriptConfigurationOverwrite;
+  configOverwrite?: TypeScriptConfigOverwrite;
   context?: string;
   build?: boolean;
   mode?: 'readonly' | 'write-tsbuildinfo' | 'write-references';
@@ -17,4 +17,4 @@ type TypeScriptReporterOptions = {
   typescriptPath?: string;
 };
 
-export { TypeScriptReporterOptions };
+export { TypeScriptWorkerOptions };
diff --git a/src/typescript/worker/get-dependencies-worker.ts b/src/typescript/worker/get-dependencies-worker.ts
index 6558abca..2cce2f10 100644
--- a/src/typescript/worker/get-dependencies-worker.ts
+++ b/src/typescript/worker/get-dependencies-worker.ts
@@ -1,6 +1,6 @@
 import type { FilesChange } from '../../files-change';
 import type { FilesMatch } from '../../files-match';
-import { exposeRpc } from '../../utils/rpc';
+import { exposeRpc } from '../../rpc';
 
 import { didConfigFileChanged, didRootFilesChanged, invalidateConfig } from './lib/config';
 import { getDependencies, invalidateDependencies } from './lib/dependencies';
diff --git a/src/typescript/worker/get-issues-worker.ts b/src/typescript/worker/get-issues-worker.ts
index fe5a4af6..0088c4a6 100644
--- a/src/typescript/worker/get-issues-worker.ts
+++ b/src/typescript/worker/get-issues-worker.ts
@@ -1,6 +1,6 @@
 import type { FilesChange } from '../../files-change';
 import type { Issue } from '../../issue';
-import { exposeRpc } from '../../utils/rpc';
+import { exposeRpc } from '../../rpc';
 
 import { invalidateArtifacts, registerArtifacts } from './lib/artifacts';
 import {
diff --git a/src/typescript/worker/lib/artifacts.ts b/src/typescript/worker/lib/artifacts.ts
index a2377c6a..c56a0ec7 100644
--- a/src/typescript/worker/lib/artifacts.ts
+++ b/src/typescript/worker/lib/artifacts.ts
@@ -57,8 +57,8 @@ function getArtifactsWorker(
       // handle circular dependencies
       continue;
     }
-    const parsedConfiguration = parseConfig(configFile, path.dirname(configFile));
-    const childArtifacts = getArtifactsWorker(parsedConfiguration, configFileContext, [
+    const parsedConfig = parseConfig(configFile, path.dirname(configFile));
+    const childArtifacts = getArtifactsWorker(parsedConfig, configFileContext, [
       ...processedConfigFiles,
       configFile,
     ]);
diff --git a/src/typescript/worker/lib/config.ts b/src/typescript/worker/lib/config.ts
index a3492e99..da7d760c 100644
--- a/src/typescript/worker/lib/config.ts
+++ b/src/typescript/worker/lib/config.ts
@@ -4,8 +4,8 @@ import type * as ts from 'typescript';
 
 import type { FilesChange } from '../../../files-change';
 import type { Issue } from '../../../issue';
-import forwardSlash from '../../../utils/path/forwardSlash';
-import type { TypeScriptConfigurationOverwrite } from '../../TypeScriptConfigurationOverwrite';
+import { forwardSlash } from '../../../utils/path/forward-slash';
+import type { TypeScriptConfigOverwrite } from '../../type-script-config-overwrite';
 
 import { createIssuesFromDiagnostics } from './diagnostics';
 import { extensions } from './extensions';
@@ -32,7 +32,7 @@ for (const extension of extensions) {
 export function parseConfig(
   configFileName: string,
   configFileContext: string,
-  configOverwriteJSON: TypeScriptConfigurationOverwrite = {}
+  configOverwriteJSON: TypeScriptConfigOverwrite = {}
 ): ts.ParsedCommandLine {
   const configFilePath = forwardSlash(configFileName);
   const parsedConfigFileJSON = typescript.readConfigFile(
diff --git a/src/typescript/worker/lib/dependencies.ts b/src/typescript/worker/lib/dependencies.ts
index 2e7812f8..fd50dd0a 100644
--- a/src/typescript/worker/lib/dependencies.ts
+++ b/src/typescript/worker/lib/dependencies.ts
@@ -55,8 +55,8 @@ function getDependenciesWorker(
       // handle circular dependencies
       continue;
     }
-    const childParsedConfiguration = parseConfig(childConfigFilePath, childConfigContext);
-    const childDependencies = getDependenciesWorker(childParsedConfiguration, childConfigContext, [
+    const childParsedConfig = parseConfig(childConfigFilePath, childConfigContext);
+    const childDependencies = getDependenciesWorker(childParsedConfig, childConfigContext, [
       ...processedConfigFiles,
       childConfigFilePath,
     ]);
diff --git a/src/typescript/worker/lib/extensions.ts b/src/typescript/worker/lib/extensions.ts
index 62bfdbf8..688450ad 100644
--- a/src/typescript/worker/lib/extensions.ts
+++ b/src/typescript/worker/lib/extensions.ts
@@ -1,5 +1,5 @@
-import type { TypeScriptExtension } from '../../extension/TypeScriptExtension';
-import { createTypeScriptVueExtension } from '../../extension/vue/TypeScriptVueExtension';
+import type { TypeScriptExtension } from '../../extension/type-script-extension';
+import { createTypeScriptVueExtension } from '../../extension/vue/type-script-vue-extension';
 
 import { config } from './worker-config';
 
diff --git a/src/typescript/worker/lib/system.ts b/src/typescript/worker/lib/system.ts
index c4cf6974..5024fcd9 100644
--- a/src/typescript/worker/lib/system.ts
+++ b/src/typescript/worker/lib/system.ts
@@ -3,7 +3,7 @@ import { dirname, join } from 'path';
 import type * as ts from 'typescript';
 
 import type { FilesMatch } from '../../../files-match';
-import forwardSlash from '../../../utils/path/forwardSlash';
+import { forwardSlash } from '../../../utils/path/forward-slash';
 
 import { memFileSystem } from './file-system/mem-file-system';
 import { passiveFileSystem } from './file-system/passive-file-system';
diff --git a/src/typescript/worker/lib/worker-config.ts b/src/typescript/worker/lib/worker-config.ts
index 1e4c8868..289278a3 100644
--- a/src/typescript/worker/lib/worker-config.ts
+++ b/src/typescript/worker/lib/worker-config.ts
@@ -1,4 +1,4 @@
-import { getRpcWorkerData } from '../../../utils/rpc';
-import type { TypeScriptReporterConfiguration } from '../../TypeScriptReporterConfiguration';
+import { getRpcWorkerData } from '../../../rpc';
+import type { TypeScriptWorkerConfig } from '../../type-script-worker-config';
 
-export const config = getRpcWorkerData() as TypeScriptReporterConfiguration;
+export const config = getRpcWorkerData() as TypeScriptWorkerConfig;
diff --git a/src/utils/array/flatten.ts b/src/utils/array/flatten.ts
deleted file mode 100644
index 47c7214d..00000000
--- a/src/utils/array/flatten.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-function flatten<T>(matrix: T[][]): T[] {
-  return matrix.reduce((flatten, array) => flatten.concat(array), []);
-}
-
-export default flatten;
diff --git a/src/utils/array/intersect.ts b/src/utils/array/intersect.ts
deleted file mode 100644
index de997cdc..00000000
--- a/src/utils/array/intersect.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-function intersect<T>(arrayA: T[] = [], arrayB: T[] = []): T[] {
-  return arrayA.filter((item) => arrayB.includes(item));
-}
-
-export default intersect;
diff --git a/src/utils/array/substract.ts b/src/utils/array/substract.ts
deleted file mode 100644
index 2927c00d..00000000
--- a/src/utils/array/substract.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-function subtract<T>(arrayA: T[] = [], arrayB: T[] = []): T[] {
-  return arrayA.filter((item) => !arrayB.includes(item));
-}
-
-export default subtract;
diff --git a/src/utils/array/unique.ts b/src/utils/array/unique.ts
deleted file mode 100644
index 3091fd5f..00000000
--- a/src/utils/array/unique.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-function unique<T>(array: T[]): T[] {
-  return Array.from(new Set(array));
-}
-
-export default unique;
diff --git a/src/utils/async/isPending.ts b/src/utils/async/is-pending.ts
similarity index 89%
rename from src/utils/async/isPending.ts
rename to src/utils/async/is-pending.ts
index ae333d87..02eae3a9 100644
--- a/src/utils/async/isPending.ts
+++ b/src/utils/async/is-pending.ts
@@ -5,4 +5,4 @@ function isPending(promise: Promise<unknown>, timeout = 100) {
   ]);
 }
 
-export default isPending;
+export { isPending };
diff --git a/src/utils/async/wait.ts b/src/utils/async/wait.ts
index 7af1d6fa..7e80efd3 100644
--- a/src/utils/async/wait.ts
+++ b/src/utils/async/wait.ts
@@ -2,4 +2,4 @@ function wait(timeout: number) {
   return new Promise((resolve) => setTimeout(resolve, timeout));
 }
 
-export default wait;
+export { wait };
diff --git a/src/utils/path/forwardSlash.ts b/src/utils/path/forward-slash.ts
similarity index 87%
rename from src/utils/path/forwardSlash.ts
rename to src/utils/path/forward-slash.ts
index df1a0a7b..e6833cac 100644
--- a/src/utils/path/forwardSlash.ts
+++ b/src/utils/path/forward-slash.ts
@@ -8,4 +8,4 @@ function forwardSlash(input: string): string {
   return path.normalize(input).replace(/\\+/g, '/');
 }
 
-export default forwardSlash;
+export { forwardSlash };
diff --git a/src/utils/path/relativeToContext.ts b/src/utils/path/relative-to-context.ts
similarity index 86%
rename from src/utils/path/relativeToContext.ts
rename to src/utils/path/relative-to-context.ts
index 2da76aae..a52ace88 100644
--- a/src/utils/path/relativeToContext.ts
+++ b/src/utils/path/relative-to-context.ts
@@ -1,6 +1,6 @@
 import path from 'path';
 
-import forwardSlash from './forwardSlash';
+import { forwardSlash } from './forward-slash';
 
 function relativeToContext(file: string, context: string) {
   let fileInContext = forwardSlash(path.relative(context, file));
diff --git a/src/utils/rpc/index.ts b/src/utils/rpc/index.ts
deleted file mode 100644
index 84661390..00000000
--- a/src/utils/rpc/index.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-export { exposeRpc } from './expose';
-export { wrapRpc } from './wrap';
-export { createRpcWorker, getRpcWorkerData, RpcWorker } from './worker';
-export { RpcExitError } from './error';
-export { RpcRemoteMethod } from './types';
diff --git a/src/watch/InclusiveNodeWatchFileSystem.ts b/src/watch/inclusive-node-watch-file-system.ts
similarity index 76%
rename from src/watch/InclusiveNodeWatchFileSystem.ts
rename to src/watch/inclusive-node-watch-file-system.ts
index e174bf67..ff0cd2f2 100644
--- a/src/watch/InclusiveNodeWatchFileSystem.ts
+++ b/src/watch/inclusive-node-watch-file-system.ts
@@ -6,9 +6,10 @@ import minimatch from 'minimatch';
 import type { Compiler } from 'webpack';
 
 import { clearFilesChange, updateFilesChange } from '../files-change';
-import type { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
+import { getInfrastructureLogger } from '../infrastructure-logger';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
 
-import type { WatchFileSystem } from './WatchFileSystem';
+import type { WatchFileSystem } from './watch-file-system';
 
 const BUILTIN_IGNORED_DIRS = ['node_modules', '.git', '.yarn', '.pnp'];
 
@@ -44,7 +45,10 @@ class InclusiveNodeWatchFileSystem implements WatchFileSystem {
   get watcher() {
     return this.watchFileSystem.watcher || this.watchFileSystem.wfs?.watcher;
   }
-  readonly dirsWatchers: Map<string, FSWatcher | undefined>;
+
+  private readonly dirsWatchers: Map<string, FSWatcher | undefined>;
+  private paused = true;
+  private deletedFiles: Set<string>;
 
   constructor(
     private watchFileSystem: WatchFileSystem,
@@ -52,10 +56,9 @@ class InclusiveNodeWatchFileSystem implements WatchFileSystem {
     private pluginState: ForkTsCheckerWebpackPluginState
   ) {
     this.dirsWatchers = new Map();
+    this.deletedFiles = new Set();
   }
 
-  private paused = true;
-
   watch: WatchFileSystem['watch'] = (
     files,
     dirs,
@@ -65,6 +68,8 @@ class InclusiveNodeWatchFileSystem implements WatchFileSystem {
     callback,
     callbackUndelayed
   ) => {
+    const { debug } = getInfrastructureLogger(this.compiler);
+
     clearFilesChange(this.compiler);
     const isIgnored = createIsIgnored(
       options?.ignored,
@@ -83,13 +88,34 @@ class InclusiveNodeWatchFileSystem implements WatchFileSystem {
     );
 
     this.watcher?.on('change', (file: string) => {
-      if (typeof file === 'string' && !isIgnored(file)) {
+      if (typeof file !== 'string') {
+        return;
+      }
+
+      if (!isIgnored(file)) {
+        debug('Detected file change', file);
+        this.deletedFiles.delete(file);
         updateFilesChange(this.compiler, { changedFiles: [file] });
+      } else {
+        debug("Detected file change but it's ignored", file);
       }
     });
     this.watcher?.on('remove', (file: string) => {
-      if (typeof file === 'string' && !isIgnored(file)) {
+      if (typeof file !== 'string') {
+        return;
+      }
+
+      if (this.deletedFiles.has(file)) {
+        debug('Skipping duplicated remove event.');
+        return;
+      }
+
+      if (!isIgnored(file)) {
+        debug('Detected file remove', file);
+        this.deletedFiles.add(file);
         updateFilesChange(this.compiler, { deletedFiles: [file] });
+      } else {
+        debug("Detected file remove but it's ignored", file);
       }
     });
 
@@ -130,14 +156,15 @@ class InclusiveNodeWatchFileSystem implements WatchFileSystem {
         const supportedExtensions = this.pluginState.lastDependencies?.extensions || [];
 
         if (!supportedExtensions.includes(extension)) {
+          debug('Detected new file add but extension is not supported', file);
           return;
         }
 
+        debug('Detected new file add', file);
+        this.deletedFiles.delete(file);
         updateFilesChange(this.compiler, { changedFiles: [file] });
 
-        const mtime = stats?.mtimeMs || stats?.ctimeMs || 1;
-
-        this.watcher?._onChange(dirToWatch, mtime, file, 'rename');
+        this.watcher?._onChange(dirToWatch, stats?.mtimeMs || stats?.ctimeMs || 1, file, 'rename');
       });
       dirWatcher.on('unlink', (file) => {
         if (this.paused) {
@@ -148,9 +175,17 @@ class InclusiveNodeWatchFileSystem implements WatchFileSystem {
         const supportedExtensions = this.pluginState.lastDependencies?.extensions || [];
 
         if (!supportedExtensions.includes(extension)) {
+          debug('Detected new file remove but extension is not supported', file);
+          return;
+        }
+
+        if (this.deletedFiles.has(file)) {
+          debug('Skipping duplicated unlink event.');
           return;
         }
 
+        debug('Detected new file remove', file);
+        this.deletedFiles.add(file);
         updateFilesChange(this.compiler, { deletedFiles: [file] });
 
         this.watcher?._onRemove(dirToWatch, file, 'rename');
diff --git a/src/watch/WatchFileSystem.ts b/src/watch/watch-file-system.ts
similarity index 95%
rename from src/watch/WatchFileSystem.ts
rename to src/watch/watch-file-system.ts
index fd3ddbec..17395bdf 100644
--- a/src/watch/WatchFileSystem.ts
+++ b/src/watch/watch-file-system.ts
@@ -11,7 +11,7 @@ interface Watchpack extends EventEmitter {
 type Watch = webpack.Compiler['watchFileSystem']['watch'];
 
 interface WatchFileSystem {
-  watcher: Watchpack;
+  watcher?: Watchpack;
   wfs?: {
     watcher: Watchpack;
   };
diff --git a/test/e2e/driver/Listener.ts b/test/e2e/driver/listener.ts
similarity index 100%
rename from test/e2e/driver/Listener.ts
rename to test/e2e/driver/listener.ts
diff --git a/test/e2e/driver/WebpackDevServerDriver.ts b/test/e2e/driver/webpack-dev-server-driver.ts
similarity index 95%
rename from test/e2e/driver/WebpackDevServerDriver.ts
rename to test/e2e/driver/webpack-dev-server-driver.ts
index c35cfb8f..aac490d4 100644
--- a/test/e2e/driver/WebpackDevServerDriver.ts
+++ b/test/e2e/driver/webpack-dev-server-driver.ts
@@ -2,9 +2,9 @@ import type { ChildProcess } from 'child_process';
 
 import stripAnsi from 'strip-ansi';
 
-import type { Listener, QueuedListener } from './Listener';
-import { createQueuedListener } from './Listener';
-import { extractWebpackErrors } from './WebpackErrorsExtractor';
+import type { Listener, QueuedListener } from './listener';
+import { createQueuedListener } from './listener';
+import { extractWebpackErrors } from './webpack-errors-extractor';
 
 interface WebpackDevServerDriver {
   process: ChildProcess;
diff --git a/test/e2e/driver/WebpackErrorsExtractor.ts b/test/e2e/driver/webpack-errors-extractor.ts
similarity index 100%
rename from test/e2e/driver/WebpackErrorsExtractor.ts
rename to test/e2e/driver/webpack-errors-extractor.ts
diff --git a/test/e2e/OutOfMemoryAndCosmiconfig.spec.ts b/test/e2e/out-of-memory-and-cosmiconfig.spec.ts
similarity index 100%
rename from test/e2e/OutOfMemoryAndCosmiconfig.spec.ts
rename to test/e2e/out-of-memory-and-cosmiconfig.spec.ts
diff --git a/test/e2e/TypeDefinitions.spec.ts b/test/e2e/type-definitions.spec.ts
similarity index 100%
rename from test/e2e/TypeDefinitions.spec.ts
rename to test/e2e/type-definitions.spec.ts
diff --git a/test/e2e/TypeScriptConfiguration.spec.ts b/test/e2e/type-script-config.spec.ts
similarity index 92%
rename from test/e2e/TypeScriptConfiguration.spec.ts
rename to test/e2e/type-script-config.spec.ts
index 85dbe349..94f85c92 100644
--- a/test/e2e/TypeScriptConfiguration.spec.ts
+++ b/test/e2e/type-script-config.spec.ts
@@ -1,9 +1,9 @@
 import path from 'path';
 
-import type { WebpackDevServerDriver } from './driver/WebpackDevServerDriver';
-import { createWebpackDevServerDriver } from './driver/WebpackDevServerDriver';
+import type { WebpackDevServerDriver } from './driver/webpack-dev-server-driver';
+import { createWebpackDevServerDriver } from './driver/webpack-dev-server-driver';
 
-describe('TypeScript Configuration', () => {
+describe('TypeScript Config', () => {
   it.each([
     { async: true, typescript: '~3.6.0', 'ts-loader': '^7.0.0' },
     { async: false, typescript: '~3.8.0', 'ts-loader': '^8.0.0' },
diff --git a/test/e2e/TypeScriptContextOption.spec.ts b/test/e2e/type-script-context-option.spec.ts
similarity index 97%
rename from test/e2e/TypeScriptContextOption.spec.ts
rename to test/e2e/type-script-context-option.spec.ts
index ce409af4..4bb0180d 100644
--- a/test/e2e/TypeScriptContextOption.spec.ts
+++ b/test/e2e/type-script-context-option.spec.ts
@@ -1,7 +1,7 @@
 import os from 'os';
 import path from 'path';
 
-import { createWebpackDevServerDriver } from './driver/WebpackDevServerDriver';
+import { createWebpackDevServerDriver } from './driver/webpack-dev-server-driver';
 
 describe('TypeScript Context Option', () => {
   it.each([
diff --git a/test/e2e/TypeScriptFormatterOption.spec.ts b/test/e2e/type-script-formatter-option.spec.ts
similarity index 95%
rename from test/e2e/TypeScriptFormatterOption.spec.ts
rename to test/e2e/type-script-formatter-option.spec.ts
index 3cf1acbb..aea8353c 100644
--- a/test/e2e/TypeScriptFormatterOption.spec.ts
+++ b/test/e2e/type-script-formatter-option.spec.ts
@@ -1,6 +1,6 @@
 import path from 'path';
 
-import { createWebpackDevServerDriver } from './driver/WebpackDevServerDriver';
+import { createWebpackDevServerDriver } from './driver/webpack-dev-server-driver';
 
 describe('TypeScript Formatter Option', () => {
   it.each([
diff --git a/test/e2e/TypeScriptPnpSupport.spec.ts b/test/e2e/type-script-pnp-support.spec.ts
similarity index 98%
rename from test/e2e/TypeScriptPnpSupport.spec.ts
rename to test/e2e/type-script-pnp-support.spec.ts
index 5a1eb38b..90a5e312 100644
--- a/test/e2e/TypeScriptPnpSupport.spec.ts
+++ b/test/e2e/type-script-pnp-support.spec.ts
@@ -2,7 +2,7 @@ import path from 'path';
 
 import semver from 'semver';
 
-import { createWebpackDevServerDriver } from './driver/WebpackDevServerDriver';
+import { createWebpackDevServerDriver } from './driver/webpack-dev-server-driver';
 
 describe('TypeScript PnP Support', () => {
   it.each([
diff --git a/test/e2e/TypeScriptSolutionBuilderApi.spec.ts b/test/e2e/type-script-solution-builder-api.spec.ts
similarity index 98%
rename from test/e2e/TypeScriptSolutionBuilderApi.spec.ts
rename to test/e2e/type-script-solution-builder-api.spec.ts
index 2ef7b51b..6b707937 100644
--- a/test/e2e/TypeScriptSolutionBuilderApi.spec.ts
+++ b/test/e2e/type-script-solution-builder-api.spec.ts
@@ -2,7 +2,7 @@ import path from 'path';
 
 import semver from 'semver';
 
-import { createWebpackDevServerDriver } from './driver/WebpackDevServerDriver';
+import { createWebpackDevServerDriver } from './driver/webpack-dev-server-driver';
 
 describe('TypeScript SolutionBuilder API', () => {
   it.each([
diff --git a/test/e2e/TypeScriptVueExtension.spec.ts b/test/e2e/type-script-vue-extension.spec.ts
similarity index 97%
rename from test/e2e/TypeScriptVueExtension.spec.ts
rename to test/e2e/type-script-vue-extension.spec.ts
index e88886dc..1a9fecb9 100644
--- a/test/e2e/TypeScriptVueExtension.spec.ts
+++ b/test/e2e/type-script-vue-extension.spec.ts
@@ -1,6 +1,6 @@
 import path from 'path';
 
-import { createWebpackDevServerDriver } from './driver/WebpackDevServerDriver';
+import { createWebpackDevServerDriver } from './driver/webpack-dev-server-driver';
 
 describe('TypeScript Vue Extension', () => {
   it.each([
diff --git a/test/e2e/TypeScriptWatchApi.spec.ts b/test/e2e/type-script-watch-api.spec.ts
similarity index 99%
rename from test/e2e/TypeScriptWatchApi.spec.ts
rename to test/e2e/type-script-watch-api.spec.ts
index 9dbe8554..7114b0af 100644
--- a/test/e2e/TypeScriptWatchApi.spec.ts
+++ b/test/e2e/type-script-watch-api.spec.ts
@@ -2,7 +2,7 @@ import path from 'path';
 
 import semver from 'semver';
 
-import { createWebpackDevServerDriver } from './driver/WebpackDevServerDriver';
+import { createWebpackDevServerDriver } from './driver/webpack-dev-server-driver';
 
 describe('TypeScript Watch API', () => {
   it.each([{ async: false }, { async: true }])(
diff --git a/test/e2e/WebpackNodeApi.spec.ts b/test/e2e/webpack-node-api.spec.ts
similarity index 100%
rename from test/e2e/WebpackNodeApi.spec.ts
rename to test/e2e/webpack-node-api.spec.ts
diff --git a/test/e2e/WebpackProductionBuild.spec.ts b/test/e2e/webpack-production-build.spec.ts
similarity index 97%
rename from test/e2e/WebpackProductionBuild.spec.ts
rename to test/e2e/webpack-production-build.spec.ts
index ccf3a0e7..fb9c6a8c 100644
--- a/test/e2e/WebpackProductionBuild.spec.ts
+++ b/test/e2e/webpack-production-build.spec.ts
@@ -2,7 +2,7 @@ import path from 'path';
 
 import stripAnsi from 'strip-ansi';
 
-import { extractWebpackErrors } from './driver/WebpackErrorsExtractor';
+import { extractWebpackErrors } from './driver/webpack-errors-extractor';
 
 describe('Webpack Production Build', () => {
   it.each([{ webpack: '5.11.0' }, { webpack: '^5.11.0' }])(
diff --git a/test/tsconfig.json b/test/tsconfig.json
index 96c07217..01580765 100644
--- a/test/tsconfig.json
+++ b/test/tsconfig.json
@@ -7,8 +7,9 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "skipDefaultLibCheck": true,
+    "resolveJsonModule": true,
     "baseUrl": "../"
   },
-  "include": ["../lib", "**/*.spec.ts"],
+  "include": ["../src", "**/*.spec.ts"],
   "exclude": ["node_modules"]
 }
diff --git a/test/unit/files-change.spec.ts b/test/unit/files-change.spec.ts
new file mode 100644
index 00000000..f3cd48ca
--- /dev/null
+++ b/test/unit/files-change.spec.ts
@@ -0,0 +1,78 @@
+import type * as webpack from 'webpack';
+
+import {
+  clearFilesChange,
+  consumeFilesChange,
+  getFilesChange,
+  updateFilesChange,
+} from '../../src/files-change';
+
+describe('files-change', () => {
+  let compiler: webpack.Compiler;
+  let otherCompiler: webpack.Compiler;
+
+  beforeEach(() => {
+    // compiler is used only as a key
+    compiler = {} as unknown as webpack.Compiler;
+    otherCompiler = {} as unknown as webpack.Compiler;
+  });
+
+  it('gets files change without modifying them', () => {
+    updateFilesChange(compiler, { changedFiles: ['foo.ts'], deletedFiles: ['bar.ts'] });
+
+    expect(getFilesChange(compiler)).toEqual({
+      changedFiles: ['foo.ts'],
+      deletedFiles: ['bar.ts'],
+    });
+    expect(getFilesChange(compiler)).toEqual({
+      changedFiles: ['foo.ts'],
+      deletedFiles: ['bar.ts'],
+    });
+  });
+
+  it('aggregates changes', () => {
+    updateFilesChange(compiler, { changedFiles: ['foo.ts', 'baz.ts'], deletedFiles: ['bar.ts'] });
+    updateFilesChange(compiler, { changedFiles: ['bar.ts'], deletedFiles: [] });
+    updateFilesChange(compiler, { changedFiles: [], deletedFiles: ['baz.ts'] });
+
+    expect(getFilesChange(compiler)).toEqual({
+      changedFiles: ['foo.ts', 'bar.ts'],
+      deletedFiles: ['baz.ts'],
+    });
+  });
+
+  it('clears changes', () => {
+    updateFilesChange(compiler, { changedFiles: ['foo.ts', 'baz.ts'], deletedFiles: ['bar.ts'] });
+    clearFilesChange(compiler);
+
+    expect(getFilesChange(compiler)).toEqual({ changedFiles: [], deletedFiles: [] });
+  });
+
+  it('consumes changes', () => {
+    updateFilesChange(compiler, { changedFiles: ['foo.ts', 'baz.ts'], deletedFiles: ['bar.ts'] });
+
+    expect(consumeFilesChange(compiler)).toEqual({
+      changedFiles: ['foo.ts', 'baz.ts'],
+      deletedFiles: ['bar.ts'],
+    });
+    expect(getFilesChange(compiler)).toEqual({ changedFiles: [], deletedFiles: [] });
+    expect(consumeFilesChange(compiler)).toEqual({ changedFiles: [], deletedFiles: [] });
+  });
+
+  it('keeps files changes data per compiler', () => {
+    updateFilesChange(compiler, { changedFiles: ['foo.ts', 'baz.ts'], deletedFiles: ['bar.ts'] });
+
+    expect(getFilesChange(otherCompiler)).toEqual({
+      changedFiles: [],
+      deletedFiles: [],
+    });
+    expect(consumeFilesChange(otherCompiler)).toEqual({
+      changedFiles: [],
+      deletedFiles: [],
+    });
+    expect(getFilesChange(compiler)).toEqual({
+      changedFiles: ['foo.ts', 'baz.ts'],
+      deletedFiles: ['bar.ts'],
+    });
+  });
+});
diff --git a/test/unit/formatter/BasicFormatter.spec.ts b/test/unit/formatter/basic-formatter.spec.ts
similarity index 83%
rename from test/unit/formatter/BasicFormatter.spec.ts
rename to test/unit/formatter/basic-formatter.spec.ts
index b267f9e2..52c5a77c 100644
--- a/test/unit/formatter/BasicFormatter.spec.ts
+++ b/test/unit/formatter/basic-formatter.spec.ts
@@ -1,7 +1,7 @@
-import { createBasicFormatter } from 'lib/formatter';
-import type { Issue } from 'lib/issue';
+import { createBasicFormatter } from 'src/formatter';
+import type { Issue } from 'src/issue';
 
-describe('formatter/BasicFormatter', () => {
+describe('formatter/basic-formatter', () => {
   it.each([
     [
       {
diff --git a/test/unit/formatter/CodeFrameFormatter.spec.ts b/test/unit/formatter/code-frame-formatter.spec.ts
similarity index 94%
rename from test/unit/formatter/CodeFrameFormatter.spec.ts
rename to test/unit/formatter/code-frame-formatter.spec.ts
index 5ec1fa4d..285d452f 100644
--- a/test/unit/formatter/CodeFrameFormatter.spec.ts
+++ b/test/unit/formatter/code-frame-formatter.spec.ts
@@ -1,10 +1,10 @@
 import * as os from 'os';
 
-import { createCodeFrameFormatter } from 'lib/formatter';
-import type { Issue } from 'lib/issue';
 import mockFs from 'mock-fs';
+import { createCodeFrameFormatter } from 'src/formatter';
+import type { Issue } from 'src/issue';
 
-describe('formatter/CodeFrameFormatter', () => {
+describe('formatter/code-frame-formatter', () => {
   beforeEach(() => {
     mockFs({
       src: {
diff --git a/test/unit/formatter/FormatterConfiguration.spec.ts b/test/unit/formatter/formatter-config.spec.ts
similarity index 86%
rename from test/unit/formatter/FormatterConfiguration.spec.ts
rename to test/unit/formatter/formatter-config.spec.ts
index c27417a1..83dec218 100644
--- a/test/unit/formatter/FormatterConfiguration.spec.ts
+++ b/test/unit/formatter/formatter-config.spec.ts
@@ -1,11 +1,11 @@
 import os from 'os';
 
-import type { FormatterOptions } from 'lib/formatter';
-import { createFormatterConfiguration } from 'lib/formatter';
-import type { Issue } from 'lib/issue';
 import mockFs from 'mock-fs';
+import type { FormatterOptions } from 'src/formatter';
+import { createFormatterConfig } from 'src/formatter';
+import type { Issue } from 'src/issue';
 
-describe('formatter/FormatterConfiguration', () => {
+describe('formatter/formatter-config', () => {
   beforeEach(() => {
     mockFs({
       src: {
@@ -71,7 +71,7 @@ describe('formatter/FormatterConfiguration', () => {
     [{ type: 'codeframe' }, CODEFRAME_FORMATTER_OUTPUT],
     [{ type: 'codeframe', options: { linesBelow: 1 } }, CUSTOM_CODEFRAME_FORMATTER_OUTPUT],
   ])('creates configuration from options', (options, expectedFormat) => {
-    const formatter = createFormatterConfiguration(options as FormatterOptions);
+    const formatter = createFormatterConfig(options as FormatterOptions);
 
     expect(formatter(issue)).toEqual(expectedFormat);
   });
diff --git a/test/unit/formatter/WebpackFormatter.spec.ts b/test/unit/formatter/webpack-formatter.spec.ts
similarity index 86%
rename from test/unit/formatter/WebpackFormatter.spec.ts
rename to test/unit/formatter/webpack-formatter.spec.ts
index 7a863eb5..720bfafa 100644
--- a/test/unit/formatter/WebpackFormatter.spec.ts
+++ b/test/unit/formatter/webpack-formatter.spec.ts
@@ -1,11 +1,11 @@
 import os from 'os';
 import { join } from 'path';
 
-import type { Formatter } from 'lib/formatter';
-import { createBasicFormatter, createWebpackFormatter } from 'lib/formatter';
-import type { Issue } from 'lib/issue';
+import type { Formatter } from 'src/formatter';
+import { createBasicFormatter, createWebpackFormatter } from 'src/formatter';
+import type { Issue } from 'src/issue';
 
-describe('formatter/WebpackFormatter', () => {
+describe('formatter/webpack-formatter', () => {
   const issue: Issue = {
     severity: 'error',
     code: 'TS123',
diff --git a/test/unit/issue/Issue.spec.ts b/test/unit/issue/issue.spec.ts
similarity index 97%
rename from test/unit/issue/Issue.spec.ts
rename to test/unit/issue/issue.spec.ts
index 42379563..c12f5f37 100644
--- a/test/unit/issue/Issue.spec.ts
+++ b/test/unit/issue/issue.spec.ts
@@ -1,5 +1,5 @@
-import type { Issue } from 'lib/issue';
-import { isIssue, deduplicateAndSortIssues } from 'lib/issue';
+import type { Issue } from 'src/issue';
+import { isIssue, deduplicateAndSortIssues } from 'src/issue';
 
 function omit<TObject extends Record<string, unknown>>(object: TObject, keys: (keyof TObject)[]) {
   const omittedObject = Object.assign({}, object);
@@ -8,7 +8,7 @@ function omit<TObject extends Record<string, unknown>>(object: TObject, keys: (k
   return omittedObject;
 }
 
-describe('issue/Issue', () => {
+describe('issue/issue', () => {
   const BASIC_ISSUE = {
     severity: 'error',
     code: 'TS4221',
diff --git a/test/unit/jest.config.js b/test/unit/jest.config.js
index d743832c..0a17a2bc 100644
--- a/test/unit/jest.config.js
+++ b/test/unit/jest.config.js
@@ -4,7 +4,7 @@ module.exports = {
   testRunner: 'jest-circus/runner',
   rootDir: '.',
   moduleNameMapper: {
-    '^lib/(.*)$': '<rootDir>/../../lib/$1',
+    '^src/(.*)$': '<rootDir>/../../src/$1',
   },
   globals: {
     'ts-jest': {
diff --git a/test/unit/ForkTsCheckerWebpackPlugin.spec.ts b/test/unit/plugin.spec.ts
similarity index 88%
rename from test/unit/ForkTsCheckerWebpackPlugin.spec.ts
rename to test/unit/plugin.spec.ts
index 8f0326f9..1a857f8a 100644
--- a/test/unit/ForkTsCheckerWebpackPlugin.spec.ts
+++ b/test/unit/plugin.spec.ts
@@ -1,6 +1,6 @@
-import { ForkTsCheckerWebpackPlugin } from 'lib/ForkTsCheckerWebpackPlugin';
+import { ForkTsCheckerWebpackPlugin } from 'src/plugin';
 
-describe('ForkTsCheckerWebpackPlugin', () => {
+describe('plugin', () => {
   it.each([{ invalid: true }, false, null, 'unknown string', { typescript: 'invalid option' }])(
     'throws an error for invalid options %p',
     (options) => {
diff --git a/test/unit/typescript/TypeScriptSupport.spec.ts b/test/unit/typescript/type-script-support.spec.ts
similarity index 80%
rename from test/unit/typescript/TypeScriptSupport.spec.ts
rename to test/unit/typescript/type-script-support.spec.ts
index a3111838..5ef2e2e6 100644
--- a/test/unit/typescript/TypeScriptSupport.spec.ts
+++ b/test/unit/typescript/type-script-support.spec.ts
@@ -1,9 +1,9 @@
 import os from 'os';
 
-import type { TypeScriptReporterConfiguration } from 'lib/typescript/TypeScriptReporterConfiguration';
+import type { TypeScriptWorkerConfig } from 'src/typescript/type-script-worker-config';
 
-describe('typescript/TypeScriptSupport', () => {
-  let configuration: TypeScriptReporterConfiguration;
+describe('typescript/type-script-support', () => {
+  let configuration: TypeScriptWorkerConfig;
 
   beforeEach(() => {
     jest.resetModules();
@@ -36,7 +36,7 @@ describe('typescript/TypeScriptSupport', () => {
   it('throws error if typescript is not installed', async () => {
     jest.setMock('typescript', undefined);
 
-    const { assertTypeScriptSupport } = await import('lib/typescript/TypeScriptSupport');
+    const { assertTypeScriptSupport } = await import('src/typescript/type-script-support');
 
     expect(() => assertTypeScriptSupport(configuration)).toThrowError(
       'When you use ForkTsCheckerWebpackPlugin with typescript reporter enabled, you must install `typescript` package.'
@@ -46,7 +46,7 @@ describe('typescript/TypeScriptSupport', () => {
   it('throws error if typescript version is lower then 3.6.0', async () => {
     jest.setMock('typescript', { version: '3.5.9' });
 
-    const { assertTypeScriptSupport } = await import('lib/typescript/TypeScriptSupport');
+    const { assertTypeScriptSupport } = await import('src/typescript/type-script-support');
 
     expect(() => assertTypeScriptSupport(configuration)).toThrowError(
       [
@@ -60,7 +60,7 @@ describe('typescript/TypeScriptSupport', () => {
     jest.setMock('typescript', { version: '3.6.0' });
     jest.setMock('fs-extra', { existsSync: () => true });
 
-    const { assertTypeScriptSupport } = await import('lib/typescript/TypeScriptSupport');
+    const { assertTypeScriptSupport } = await import('src/typescript/type-script-support');
 
     expect(() => assertTypeScriptSupport(configuration)).not.toThrowError();
   });
@@ -69,7 +69,7 @@ describe('typescript/TypeScriptSupport', () => {
     jest.setMock('typescript', { version: '3.8.0' });
     jest.setMock('fs-extra', { existsSync: () => false });
 
-    const { assertTypeScriptSupport } = await import('lib/typescript/TypeScriptSupport');
+    const { assertTypeScriptSupport } = await import('src/typescript/type-script-support');
 
     expect(() => assertTypeScriptSupport(configuration)).toThrowError(
       [
diff --git a/test/unit/typescript/TypeScriptReporterConfiguration.spec.ts b/test/unit/typescript/type-script-worker-config.spec.ts
similarity index 67%
rename from test/unit/typescript/TypeScriptReporterConfiguration.spec.ts
rename to test/unit/typescript/type-script-worker-config.spec.ts
index 149b8a7d..28b7a447 100644
--- a/test/unit/typescript/TypeScriptReporterConfiguration.spec.ts
+++ b/test/unit/typescript/type-script-worker-config.spec.ts
@@ -1,15 +1,15 @@
 import path from 'path';
 
-import type { TypeScriptReporterConfiguration } from 'lib/typescript/TypeScriptReporterConfiguration';
-import type { TypeScriptReporterOptions } from 'lib/typescript/TypeScriptReporterOptions';
+import type { TypeScriptWorkerConfig } from 'src/typescript/type-script-worker-config';
+import type { TypeScriptWorkerOptions } from 'src/typescript/type-script-worker-options';
 import type webpack from 'webpack';
 
-describe('typescript/TypeScriptsReporterConfiguration', () => {
+describe('typescript/type-scripts-worker-config', () => {
   let compiler: webpack.Compiler;
-  let createTypeScriptVueExtensionConfiguration: jest.Mock;
+  let createTypeScriptVueExtensionConfig: jest.Mock;
   const context = '/webpack/context';
 
-  const configuration: TypeScriptReporterConfiguration = {
+  const configuration: TypeScriptWorkerConfig = {
     enabled: true,
     memoryLimit: 2048,
     configFile: path.normalize(path.resolve(context, 'tsconfig.json')),
@@ -46,12 +46,12 @@ describe('typescript/TypeScriptsReporterConfiguration', () => {
         context,
       },
     } as webpack.Compiler;
-    createTypeScriptVueExtensionConfiguration = jest.fn(() => ({
+    createTypeScriptVueExtensionConfig = jest.fn(() => ({
       enabled: false,
       compiler: 'vue-template-compiler',
     }));
-    jest.setMock('lib/typescript/extension/vue/TypeScriptVueExtensionConfiguration', {
-      createTypeScriptVueExtensionConfiguration,
+    jest.setMock('src/typescript/extension/vue/type-script-vue-extension-config', {
+      createTypeScriptVueExtensionConfig,
     });
   });
   afterEach(() => {
@@ -101,24 +101,19 @@ describe('typescript/TypeScriptsReporterConfiguration', () => {
       },
     ],
     [{ profile: true }, { ...configuration, profile: true }],
-  ])('creates configuration from options %p', async (options, expectedConfiguration) => {
-    const { createTypeScriptReporterConfiguration } = await import(
-      'lib/typescript/TypeScriptReporterConfiguration'
-    );
-    const configuration = createTypeScriptReporterConfiguration(
-      compiler,
-      options as TypeScriptReporterOptions
+  ])('creates configuration from options %p', async (options, expectedConfig) => {
+    const { createTypeScriptWorkerConfig } = await import(
+      'src/typescript/type-script-worker-config'
     );
+    const config = createTypeScriptWorkerConfig(compiler, options as TypeScriptWorkerOptions);
 
-    expect(configuration).toEqual(expectedConfiguration);
+    expect(config).toEqual(expectedConfig);
   });
 
   it('passes vue options to the vue extension', async () => {
-    createTypeScriptVueExtensionConfiguration.mockImplementation(
-      () => 'returned from vue extension'
-    );
-    const { createTypeScriptReporterConfiguration } = await import(
-      'lib/typescript/TypeScriptReporterConfiguration'
+    createTypeScriptVueExtensionConfig.mockImplementation(() => 'returned from vue extension');
+    const { createTypeScriptWorkerConfig } = await import(
+      'src/typescript/type-script-worker-config'
     );
 
     const vueOptions = {
@@ -126,11 +121,11 @@ describe('typescript/TypeScriptsReporterConfiguration', () => {
       compiler: 'test-compiler',
     };
 
-    const configuration = createTypeScriptReporterConfiguration(compiler, {
+    const config = createTypeScriptWorkerConfig(compiler, {
       extensions: { vue: vueOptions },
     });
 
-    expect(createTypeScriptVueExtensionConfiguration).toHaveBeenCalledWith(vueOptions);
-    expect(configuration.extensions.vue).toEqual('returned from vue extension');
+    expect(createTypeScriptVueExtensionConfig).toHaveBeenCalledWith(vueOptions);
+    expect(config.extensions.vue).toEqual('returned from vue extension');
   });
 });
diff --git a/test/unit/utils/async/pool.spec.ts b/test/unit/utils/async/pool.spec.ts
index 81f01fb3..3418d214 100644
--- a/test/unit/utils/async/pool.spec.ts
+++ b/test/unit/utils/async/pool.spec.ts
@@ -1,4 +1,4 @@
-import { createPool } from 'lib/utils/async/pool';
+import { createPool } from 'src/utils/async/pool';
 
 function wait(timeout: number) {
   return new Promise((resolve) => setTimeout(resolve, timeout));