up n_m

node_modules/fork-ts-checker-webpack-plugin/lib/logger/Logger.d.ts

@@ -0,0 +1,6 @@
+interface Logger {
+    info: (message: string) => void;
+    log: (message: string) => void;
+    error: (message: string) => void;
+}
+export default Logger;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/Logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerConfiguration.d.ts

@@ -0,0 +1,10 @@
+import LoggerOptions from './LoggerOptions';
+import Logger from './Logger';
+import webpack from 'webpack';
+interface LoggerConfiguration {
+    infrastructure: Logger;
+    issues: Logger;
+    devServer: boolean;
+}
+declare function createLoggerConfiguration(compiler: webpack.Compiler, options: LoggerOptions | undefined): LoggerConfiguration;
+export { LoggerConfiguration, createLoggerConfiguration };

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerConfiguration.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LoggerFactory_1 = require("./LoggerFactory");
+function createLoggerConfiguration(compiler, options) {
+    return {
+        infrastructure: LoggerFactory_1.createLogger((options && options.infrastructure) || 'silent', compiler),
+        issues: LoggerFactory_1.createLogger((options && options.issues) || 'console', compiler),
+        devServer: (options === null || options === void 0 ? void 0 : options.devServer) !== false,
+    };
+}
+exports.createLoggerConfiguration = createLoggerConfiguration;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerFactory.d.ts

@@ -0,0 +1,5 @@
+import webpack from 'webpack';
+import Logger from './Logger';
+declare type LoggerType = 'console' | 'webpack-infrastructure' | 'silent';
+declare function createLogger(type: LoggerType | Logger, compiler: webpack.Compiler): Logger;
+export { createLogger, LoggerType };

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerFactory.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WebpackInfrastructureLogger_1 = require("./WebpackInfrastructureLogger");
+const PartialLogger_1 = require("./PartialLogger");
+function createLogger(type, compiler) {
+    if (typeof type !== 'string') {
+        return type;
+    }
+    switch (type) {
+        case 'webpack-infrastructure':
+            return (WebpackInfrastructureLogger_1.createWebpackInfrastructureLogger(compiler) ||
+                PartialLogger_1.createPartialLogger(['log', 'error'], console));
+        case 'silent':
+            return PartialLogger_1.createPartialLogger([], console);
+        case 'console':
+        default:
+            return console;
+    }
+}
+exports.createLogger = createLogger;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerOptions.d.ts

@@ -0,0 +1,8 @@
+import { LoggerType } from './LoggerFactory';
+import Logger from './Logger';
+declare type LoggerOptions = {
+    infrastructure?: LoggerType | Logger;
+    issues?: LoggerType | Logger;
+    devServer?: boolean;
+};
+export default LoggerOptions;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/LoggerOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/fork-ts-checker-webpack-plugin/lib/logger/PartialLogger.d.ts

@@ -0,0 +1,4 @@
+import Logger from './Logger';
+declare type LoggerMethods = 'info' | 'log' | 'error';
+declare function createPartialLogger(methods: LoggerMethods[], logger: Logger): Logger;
+export { createPartialLogger };

node_modules/fork-ts-checker-webpack-plugin/lib/logger/PartialLogger.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createPartialLogger(methods, logger) {
+    return {
+        info: (message) => (methods.includes('info') ? logger.info(message) : undefined),
+        log: (message) => (methods.includes('log') ? logger.log(message) : undefined),
+        error: (message) => (methods.includes('error') ? logger.error(message) : undefined),
+    };
+}
+exports.createPartialLogger = createPartialLogger;

node_modules/fork-ts-checker-webpack-plugin/lib/logger/WebpackInfrastructureLogger.d.ts

@@ -0,0 +1,4 @@
+import webpack from 'webpack';
+import Logger from './Logger';
+declare function createWebpackInfrastructureLogger(compiler: webpack.Compiler): Logger | undefined;
+export { createWebpackInfrastructureLogger };

node_modules/fork-ts-checker-webpack-plugin/lib/logger/WebpackInfrastructureLogger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isInfrastructureLoggerProvider(candidate) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return !!candidate.getInfrastructureLogger;
+}
+function createWebpackInfrastructureLogger(compiler) {
+    return isInfrastructureLoggerProvider(compiler)
+        ? compiler.getInfrastructureLogger('ForkTsCheckerWebpackPlugin')
+        : undefined;
+}
+exports.createWebpackInfrastructureLogger = createWebpackInfrastructureLogger;