@mindbox/frontend/build/webpack.config.js

"use strict";

const fs = require("fs");
const rimraf = require("rimraf");
const { spawnSync } = require("child_process");
const path = require("path");
const glob = require("glob");
const webpack = require("webpack");
const CaseSensitivePathsPlugin = require("case-sensitive-paths-webpack-plugin");
const CircularDependencyPlugin = require("circular-dependency-plugin");

const Visualizer = require("webpack-visualizer-plugin");

const ForkTsCheckerWebpackPlugin = require("fork-ts-checker-webpack-plugin");
const FriendlyErrorsWebpackPlugin = require("friendly-errors-webpack-plugin");
const chalk = require("chalk");
const NullPlugin = require("webpack-null-plugin");
const TerserPlugin = require("terser-webpack-plugin");
const Terser = require("terser");
const Concat = require("concat-with-sourcemaps");
const WebpackBuildNotifierPlugin = require("webpack-build-notifier");

const I18nPlugin = require("./tools/i18n-bundler-plugin");
const runnerArgs = process.argv.slice(2);

/**
 * Модули, необходимые для сборки частей конфигурации.
 */
const requirements = {
    path: path,
    glob: glob,
    rimraf: rimraf
};

const solutionDir = path.join(".");
const dist = path.join(solutionDir, "dist");

const createConfig = env => {
    const transpileOnly = (env && env["transpile-only"]) || false;
    const visualizeResults = (env && env["visualizeResults"]) || false;
    const isInProduction = (env && env["production"]) || false;
    const projects = (env && env["project"]) || null;
    const noLegacy = (env && env["no-legacy"]) || null;

    const buildContext = {
        isInProduction: isInProduction,
        transpileOnly: transpileOnly,
        visualizeResults: visualizeResults,
        projects: projects,
        buildLegacy: !noLegacy
    };

    return getConfiguration(buildContext);
};

const testFileMarkers = [
    "{T,t}ests.ts{,x}",
    ".spec.ts{,x}",
    "initialization.ts"
];

const getTestFiles = (projectPath, testDirectories) => {
    let result = [];

    for (let testRoot of testDirectories)
        for (let marker of testFileMarkers) {
            const testFilesPath = path.join(
                projectPath,
                testRoot,
                `**/*${marker}`
            );
            const subResult = glob
                .sync(testFilesPath)
                .map(testFile => path.resolve(testFile));
            result = [...result, ...subResult];
        }

    return result;
};

const getDeveloperSettings = () => {
    const developerSettingsFilePath = path.resolve(
        __dirname,
        "./development-settings.json"
    );

    if (fs.existsSync(developerSettingsFilePath))
        return require("./development-settings.json");
};

const resolvePathToAbsolute = (baseDir, targetPath) => {
    if (path.isAbsolute(targetPath)) return targetPath;
    else if (baseDir) return path.join(baseDir, targetPath);
    else
        throw new Error(
            "Can't resolve relative path without base dir: " + relativePath
        );
};

/**
 * Получение конфигурации webpack'а для проекта.
 * @param buildContext - параметры билда
 * @returns {{}} Конфигурация webpack'а.
 */
const getConfiguration = buildContext => {
    const { isInProduction, projects, buildLegacy } = buildContext;

    if (buildLegacy) compileLegacyProjects(isInProduction);

    const environment = getEnvironmentVariable(isInProduction);

    const configurations = getProjectConfigurationProvidersPaths(projects).map(
        providerPath => {
            try {
                const providerDir = path.dirname(providerPath);
                const provider = require(providerPath);
                const providerContext = {
                    projectPath: providerDir,
                    requirements: requirements,
                    environment: environment
                };
                const projectConfiguration = provider(providerContext);

                const developerSettings = getDeveloperSettings();

                function resolveDistForModule(name) {
                    if (name && developerSettings && developerSettings.parts)
                        return developerSettings.parts[name];
                }

                function resolveRelative(relativePath) {
                    if (!relativePath) return undefined;

                    if (path.isAbsolute(relativePath))
                        throw new Error(
                            "Path specified in configuration is absolute: " +
                                relativePath
                        );

                    return path.join(providerDir, relativePath);
                }

                let entriesDebugDist = null;
                let librariesDebugDist = null;
                let resolveCommonChunkDebug = null;

                const debugDist = resolveDistForModule(
                    projectConfiguration.name
                );
                if (debugDist) {
                    if (debugDist.entriesDist)
                        entriesDebugDist = resolvePathToAbsolute(
                            developerSettings.baseDir,
                            debugDist.entriesDist
                        );

                    if (debugDist.librariesDist)
                        librariesDebugDist = resolvePathToAbsolute(
                            developerSettings.baseDir,
                            debugDist.librariesDist
                        );

                    if (debugDist.commonChunkDist) {
                        const commonChunkDebugDist = resolvePathToAbsolute(
                            developerSettings.baseDir,
                            debugDist.commonChunkDist
                        );

                        resolveCommonChunkDebug = filePath =>
                            path.join(
                                commonChunkDebugDist,
                                path.parse(filePath).base
                            );
                    }
                }

                projectConfiguration.tsconfigPath = resolveRelative(
                    projectConfiguration.tsconfigPath
                );
                projectConfiguration.entries = projectConfiguration.entries.map(
                    entry => ({
                        ...entry,
                        outputPath: path.join(
                            entriesDebugDist ||
                                resolveRelative(entry.outputPath),
                            entry.name
                        ),
                        source: resolveRelative(entry.source)
                    })
                );

                if (projectConfiguration.commonChunk) {
                    projectConfiguration.commonChunk = (
                        resolveCommonChunkDebug || resolveRelative
                    )(projectConfiguration.commonChunk);
                }

                if (projectConfiguration.testEntries) {
                    projectConfiguration.entries = [
                        ...projectConfiguration.entries,
                        {
                            outputPath: path.join(
                                resolveRelative(
                                    projectConfiguration.testEntries.outputPath
                                ),
                                projectConfiguration.testEntries.name
                            ),
                            source: getTestFiles(
                                providerDir,
                                projectConfiguration.testEntries.sourcePaths
                            )
                        }
                    ];
                }

                if (projectConfiguration.libraries) {
                    projectConfiguration.libraries = projectConfiguration.libraries.map(
                        libraryPack => ({
                            ...libraryPack,
                            outputPath:
                                librariesDebugDist ||
                                resolveRelative(libraryPack.outputPath),
                            files: libraryPack.files
                                .map(f =>
                                    Array.isArray(f)
                                        ? f[isInProduction ? 1 : 0]
                                        : f
                                )
                                .map(resolveRelative)
                        })
                    );
                }

                if (projectConfiguration.localizationPaths) {
                    projectConfiguration.localizationBundles = {
                        [projectConfiguration.name]: projectConfiguration.localizationPaths.map(
                            resolveRelative
                        )
                    };
                }

                return {
                    projectConfiguration: projectConfiguration,
                    webpackConfigurationBuilder: configurationTemplateBuilder(
                        buildContext
                    )
                };
            } catch (err) {
                throw `Error processing configuration ${providerPath}: ` + err;
            }
        }
    );

    const projectsMap = {};

    for (let { projectConfiguration } of configurations) {
        projectsMap[projectConfiguration.name] = projectConfiguration;
    }

    const rootConfigurations = [];
    for (let configuration of configurations) {
        const projectConfiguration = configuration.projectConfiguration;

        if (typeof projectConfiguration.extends === "undefined") {
            rootConfigurations.push(configuration);
            continue;
        }

        const extendedConfiguration = projectsMap[projectConfiguration.extends];

        if (projectConfiguration.entries) {
            extendedConfiguration.entries = [
                ...extendedConfiguration.entries,
                ...projectConfiguration.entries
            ];
        }

        if (projectConfiguration.localizationBundles) {
            extendedConfiguration.localizationBundles = {
                ...(extendedConfiguration.localizationBundles || {}),
                ...projectConfiguration.localizationBundles
            };
        }

        if (projectConfiguration.libraries) {
            extendedConfiguration.libraries = [
                ...(extendedConfiguration.libraries || []),
                ...projectConfiguration.libraries
            ];
        }
    }

    const entryOutputPaths = rootConfigurations
        .map(c => c.projectConfiguration.entries.map(entry => entry.outputPath))
        .reduce((a, b) => [...a, ...b], []);

    new Set(
        entryOutputPaths
            .map(entryPath => path.dirname(entryPath))
            .map(distDir => path.resolve(distDir))
            .filter(distDir => distDir.includes("dist"))
    ).forEach(distDir => rimraf.sync(distDir));

    const result = [];
    for (let {
        projectConfiguration,
        webpackConfigurationBuilder
    } of rootConfigurations) {
        var configuration = webpackConfigurationBuilder(projectConfiguration);
        result.push(configuration);
        if (projectConfiguration.libraries) {
            bundleLibraries(projectConfiguration.libraries, isInProduction);
        }
    }

    getProjectAssetsProvidersPaths(projects).map(providerPath => {
        try {
            copyAssets(providerPath);
        } catch (err) {
            throw `Error processing assets ${providerPath}: ` + err;
        }
    });

    // for debugging final configuration:
    // fs.writeFileSync(path.resolve(__dirname, "./finalConfig.json"), JSON.stringify(result, null, 2));

    return result;
};

const getProjectConfigurationProvidersPaths = projects => {
    return getProjectProvidersPaths(
        projects,
        false,
        configuration => configuration.parts
    );
};

const getProjectAssetsProvidersPaths = projects => {
    return getProjectProvidersPaths(
        projects,
        true,
        configuration => configuration.assets
    );
};

const getProjectProvidersPaths = (
    projects,
    canSkipProject,
    configurationPropertyProvider
) => {
    const configurationFilePath = path.resolve(__dirname, "./projects.json");
    if (!fs.existsSync(configurationFilePath))
        throw new Error(
            `File with projects list not found in '${configurationFilePath}'`
        );
    const availableProjects = Object.entries(
        configurationPropertyProvider(
            JSON.parse(fs.readFileSync(configurationFilePath).toString())
        )
    );
    const resultingConfigurationsPaths = new Set();
    const desiredProjects =
        projects != null
            ? typeof projects === "string"
                ? [projects]
                : projects
            : availableProjects.map(ap => ap[0]);
    for (let desiredProject of desiredProjects) {
        const project = availableProjects.find(ap => ap[0] === desiredProject);
        if (project == null)
            if (canSkipProject) continue;
            else
                throw new Error(
                    `Project with name '${desiredProject}' is unknown`
                );
        for (let configurationPath of project[1])
            resultingConfigurationsPaths.add(configurationPath);
    }

    const result = Array.from(resultingConfigurationsPaths)
        .map(relativePath => path.join(solutionDir, relativePath))
        .map(relativePath => path.resolve(relativePath));

    return result;
};

const configurationTemplateBuilder = buildContext => projectConfiguration => {
    const { isInProduction, transpileOnly, visualizeResults } = buildContext;
    const environment = getEnvironmentVariable(isInProduction);

    const {
        entries,
        tsconfigPath,
        commonChunk,
        localizationBundles
    } = projectConfiguration;

    const webpackConfigEntry = {};
    for (let entry of entries) {
        const entryPath = path.relative(solutionDir, entry.outputPath);
        webpackConfigEntry[entryPath] = entry.source;
    }

    const webpackOptimization =
        typeof commonChunk != "undefined"
            ? {
                  splitChunks: {
                      cacheGroups: {
                          commons: {
                              name: path.relative(solutionDir, commonChunk),
                              chunks: "initial",
                              minChunks: 2
                          }
                      }
                  }
              }
            : undefined;

    const localizationBundlesMap = localizationBundles || {};
    const developerSettings = getDeveloperSettings();

    let relativeLocalizationTargetDirectory =
        developerSettings && developerSettings.localizationDist
            ? path.relative(
                  solutionDir,
                  resolvePathToAbsolute(
                      developerSettings.baseDir,
                      developerSettings.localizationDist
                  )
              )
            : path.join(dist, "content", "localization");

    return {
        mode: "none",
        devtool: getDevTool(isInProduction),
        watch: isWatch(),
        module: {
            rules: [
                getTsLoader(tsconfigPath),
                {
                    test: /\.js$/,
                    exclude: /node_modules/,
                    loader: "source-map-loader",
                    enforce: "pre"
                },

                // NOTE: Exposes `react` and `react-dom` to use from an external
                //       code.
                {
                    test: require.resolve("react"),
                    use: [
                        {
                            loader: "expose-loader",
                            options: "React"
                        }
                    ]
                },
                {
                    test: require.resolve("react-dom"),
                    use: [
                        {
                            loader: "expose-loader",
                            options: "ReactDOM"
                        }
                    ]
                },

                {
                    test: /\.scss$/,
                    loaders: [
                        "style-loader",
                        "css-loader",
                        "postcss-loader",
                        "fast-sass-loader"
                    ]
                },
                {
                    test: /\.css$/,
                    loaders: ["style-loader", "css-loader", "postcss-loader"]
                },
                // Fonts and images would be inlined.
                {
                    test: /\.(png|jpg|gif|svg|eot|ttf|woff|woff2)$/,
                    loader: "url-loader",
                    options: {
                        limit: 999999
                    }
                }
            ]
        },

        plugins: [
            ...Object.keys(localizationBundlesMap).map(
                name =>
                    new I18nPlugin(
                        relativeLocalizationTargetDirectory + "/" + name,
                        localizationBundlesMap[name]
                    )
            ),
            getUglifyJsPlugin(isInProduction),
            new CaseSensitivePathsPlugin(),
            new CircularDependencyPlugin({
                exclude: /node_modules/, // Не хотим проверять зависимости в чужих модулях
                failOnError: true
            }),
            // Не хотим импортить все локали для момента.
            new webpack.ContextReplacementPlugin(
                /moment[\/\\]locale$/,
                /ru-ru|en-us/
            ),
            new webpack.DefinePlugin({
                __VERSION__: JSON.stringify(require("../package.json").version),
                "process.env.NODE_ENV": JSON.stringify(environment)
            }),
            getFriendlyErrorsPlugin(),
            getTsCheckPlugin(isInProduction, transpileOnly, tsconfigPath),
            getVizualizerPlugin(visualizeResults),
            new WebpackBuildNotifierPlugin({
                title: "Frontend Build",
                suppressSuccess: "always"
            })
        ],
        resolve: {
            // Нужно уметь резолвить модули из .ts и .tsx
            extensions: [".ts", ".tsx", ".js", ".json"],

            // Магия вебпака
            alias: {
                administration: path.resolve(
                    __dirname,
                    "..",
                    "Administration",
                    "src"
                ),
                "administration-tests": path.resolve(
                    __dirname,
                    "..",
                    "Administration",
                    "tests"
                ),
                directcrm: path.resolve(__dirname, "..", "DirectCrm", "src"),
                "directcrm-tests": path.resolve(
                    __dirname,
                    "..",
                    "DirectCrm",
                    "tests"
                ),
                mailings: path.resolve(
                    __dirname,
                    "..",
                    "DirectCrm",
                    "Mailings",
                    "src"
                ),
                email: path.resolve(
                    __dirname,
                    "..",
                    "DirectCrm",
                    "Mailings",
                    "Email",
                    "src"
                ),
                sms: path.resolve(
                    __dirname,
                    "..",
                    "DirectCrm",
                    "Mailings",
                    "Sms",
                    "src"
                ),
                viber: path.resolve(
                    __dirname,
                    "..",
                    "DirectCrm",
                    "Mailings",
                    "Viber",
                    "src"
                ),
                "mobile-push": path.resolve(
                    __dirname,
                    "..",
                    "DirectCrm",
                    "Mailings",
                    "MobilePush",
                    "src"
                ),
                "web-push": path.resolve(
                    __dirname,
                    "..",
                    "DirectCrm",
                    "Mailings",
                    "WebPush",
                    "src"
                ),
                retail: path.resolve(
                    __dirname,
                    "..",
                    "DirectCrm",
                    "Retail",
                    "src"
                ),
                tracker: path.resolve(
                    __dirname,
                    "..",
                    "Javascript.SDK",
                    "Tracker"
                ),
                common: path.resolve(
                    __dirname,
                    "..",
                    "Javascript.SDK",
                    "Common"
                )
            }
        },

        externals: [
            {
                react: "React",
                "react-dom": "ReactDOM",
                "react-dom-server": "ReactDOMServer",
                "react-dom/test-utils": "TestUtils",
                underscore: "_",
                moment: "moment",
                redux: "Redux",
                "react-redux": "ReactRedux",
                "react-ace": "ReactAce",
                brace: "ace",
                "emoji-mart-lite": "EmojiMartLite"
            }
        ],

        stats: {
            timings: true,
            modules: false,
            hash: false,
            version: true,

            // Отрисовывает ошибки плагин
            errors: false,
            warnings: false
        },

        output: {
            path: path.resolve(solutionDir),
            filename: "[name].js",
            devtoolModuleFilenameTemplate: info =>
                "file:///" +
                path.resolve(info.absoluteResourcePath).replace(/\\/g, "/"),
            sourceMapFilename: "[name].js.map"
        },
        optimization: webpackOptimization,
        entry: webpackConfigEntry
    };
};

/**
 * Плагин для красивой отрисовки ошибок.
 */
const getFriendlyErrorsPlugin = () => {
    return new FriendlyErrorsWebpackPlugin({
        clearConsole: false
    });
};

/**
 * Плагин для проверки типов. Не подключается в режиме транспиляции.
 */
const getTsCheckPlugin = (isInProduction, transpileOnly, tsconfigPath) => {
    if (transpileOnly) {
        console.log(chalk.blue("Transpile only"));
        return new NullPlugin();
    }

    return new ForkTsCheckerWebpackPlugin({
        checkSyntacticErrors: true,
        async: false,
        tslint: getTslintConfigPath(isInProduction),
        tsconfig: tsconfigPath
    });
};

const getVizualizerPlugin = visualizeResults => {
    if (!visualizeResults) return new NullPlugin();

    console.log(
        chalk.blue(
            "Dependencies snapshot will be reported to Webpack.Visualizer.html"
        )
    );

    return new Visualizer({
        filename: "Webpack.Visualizer.html"
    });
};

/**
 * Получение конфигурации сборки
 * @returns {string} "production" либо "development".
 */
const getEnvironmentVariable = isInProduction => {
    return isInProduction ? "production" : "development";
};

const getDevTool = isInProduction => {
    return isInProduction ? "source-map" : "cheap-module-source-map";
};

const getUglifyJsPlugin = isInProduction => {
    return isInProduction
        ? new TerserPlugin({
              sourceMap: true,
              parallel: true
          })
        : new NullPlugin();
};

const getTslintConfigPath = isInProduction => {
    return isInProduction ? "./tslint-production.json" : "./tslint.json";
};

const isWatch = () => {
    return runnerArgs.indexOf("--watch") >= 0 || runnerArgs.indexOf("-w") >= 0;
};

const lintLegacyProjects = () => {
    const args = [
        "./node_modules/tslint/bin/tslint",
        "--project",
        "./legacy.tsconfig.json",
        "--config",
        "./tslint-legacy.json"
    ];

    const childProcess = spawnSync("node", args);

    if (childProcess.status !== 0) {
        console.log(chalk.red.bold(childProcess.stdout.toString()));

        console.log(
            chalk.bgRed.black.bold(" LEGACY TS "),
            chalk.red(`lint failed with code ${childProcess.status}`)
        );

        process.exit(childProcess.status);
    }
};

/**
 * Компилирует старые проекты без бандлинга.
 */
const compileLegacyProjects = isInProduction => {
    console.log(
        chalk.bgYellow.black.bold(" LEGACY TS "),
        chalk.yellow("build started")
    );

    const args = [
        "./node_modules/typescript/bin/tsc",
        "--project",
        "./legacy.tsconfig.json",
        "--noEmitOnError"
    ];

    if (isWatch()) {
        console.log(
            chalk.bgYellow.black.bold(" LEGACY TS "),
            chalk.yellow("file changes will"),
            chalk.bgRed.black.bold("!NOT!"),
            chalk.yellow("be watched")
        );
    }

    const childProcess = spawnSync("node", args);

    if (childProcess.status !== 0) {
        console.log(chalk.red.bold(childProcess.stdout.toString()));

        console.log(
            chalk.bgRed.black.bold(" LEGACY TS "),
            chalk.red(`build failed with code ${childProcess.status}`)
        );

        process.exit(childProcess.status);
    }

    if (isInProduction) lintLegacyProjects();

    console.log(
        chalk.bgYellow.black.bold(" LEGACY TS "),
        chalk.yellow("build finished")
    );
};

const minifyPackedLibrary = (name, outputPath, content) => {
    const library = {
        [path.join(
            path.relative(solutionDir, outputPath),
            name
        )]: content.toString()
    };

    let options = {
        compress: false,
        mangle: true
    };

    const minifyResult = Terser.minify(library, options);

    if (minifyResult.error) {
        throw minifyResult.error;
    }

    return {
        content: minifyResult.code
    };
};

const concatLibrariesWithoutMinification = (files, bundleFileName) => {
    const concat = new Concat(true, bundleFileName, "\n");
    files.forEach(file => {
        const relativePath = path.relative(solutionDir, file);
        const content = fs.readFileSync(file).toString();

        const sourceMapPath = file + ".map";

        if (fs.existsSync(sourceMapPath)) {
            const sourceMapContent = fs.readFileSync(sourceMapPath).toString();
            const sourceMapReference = content.lastIndexOf(
                "//# sourceMappingURL="
            );
            if (sourceMapReference != -1) {
                concat.add(
                    relativePath,
                    content.substr(0, sourceMapReference),
                    sourceMapContent
                );
            } else {
                concat.add(relativePath, content, sourceMapContent);
            }
        } else {
            concat.add(relativePath, content);
        }
    });

    return {
        sourceMap: concat.sourceMap,
        content: concat.content
    };
};

const bundleLibraries = (libraries, isInProduction) => {
    if (libraries == null) return;

    for (let library of libraries) {
        const { name, outputPath, files } = library;
        const relativeOutputPath = path.join(
            ".",
            path.relative(solutionDir, outputPath)
        );

        console.log(
            chalk.bgCyanBright.black(" LIBRARY ") +
            chalk.reset(" ") + // brightness bug
                chalk.reset.cyanBright(
                    `"${name}.js" will be assembled in ${relativeOutputPath}`
                )
        );

        const bundleFileName = name + ".js";
        const mapName = name + ".js.map";

        let bundleResult = concatLibrariesWithoutMinification(
            files,
            bundleFileName
        );

        if (!fs.existsSync(outputPath)) {
            outputPath.split(path.sep).reduce((prevPath, folder) => {
                const currentPath = path.join(prevPath, folder, path.sep);
                if (!fs.existsSync(currentPath)) {
                    fs.mkdirSync(currentPath);
                }
                return currentPath;
            }, "");
        }

        if (isInProduction) {
            bundleResult = minifyPackedLibrary(
                name,
                outputPath,
                bundleResult.content
            );
            fs.writeFileSync(
                path.join(outputPath, bundleFileName),
                bundleResult.content
            );
        } else {
            fs.writeFileSync(
                path.join(outputPath, mapName),
                bundleResult.sourceMap
            );
            fs.writeFileSync(
                path.join(outputPath, bundleFileName),
                bundleResult.content.toString() +
                    `\n//# sourceMappingURL=${mapName}\n`
            );
        }
    }
};

const copyAssets = assetsProviderPath => {
    const providerDir = path.dirname(assetsProviderPath);
    const provider = require(assetsProviderPath);
    const assets = provider();

    if (assets == null) return;

    const developerSettings = getDeveloperSettings();

    function resolveDistForAsset(name) {
        if (name && developerSettings && developerSettings.assets)
            return developerSettings.assets[name];
    }

    for (let asset of assets) {
        const debugDist = resolveDistForAsset(asset.name);

        const absoluteDestinationDirectory =
            debugDist && debugDist.destinationDirectory
                ? resolvePathToAbsolute(
                      developerSettings.baseDir,
                      debugDist.destinationDirectory
                  )
                : resolvePathToAbsolute(
                      providerDir,
                      asset.destinationDirectory
                  );

        if (!fs.existsSync(absoluteDestinationDirectory)) {
            absoluteDestinationDirectory
                .split(path.sep)
                .reduce((prevPath, folder) => {
                    const currentPath = path.join(prevPath, folder, path.sep);
                    if (!fs.existsSync(currentPath)) {
                        fs.mkdirSync(currentPath);
                    }
                    return currentPath;
                }, "");
        }

        for (let sourceFile of asset.sourceFiles) {
            const absoluteSourceFile = resolvePathToAbsolute(
                providerDir,
                sourceFile
            );

            const fileName = path.parse(absoluteSourceFile).base;
            const absoluteDestinationFile = path.join(
                absoluteDestinationDirectory,
                fileName
            );

            fs.copyFile(absoluteSourceFile, absoluteDestinationFile, error => {
                if (error) {
                    throw error;
                }
            });
        }
    }
};

const getTsLoader = tsconfigPath => {
    return {
        test: /\.tsx?$/,
        exclude: /node_modules/,
        use: [
            {
                loader: "ts-loader",
                options: {
                    logLevel: "info",
                    happyPackMode: true,
                    configFile: tsconfigPath
                }
            }
        ]
    };
};

module.exports = createConfig;