@excitare/cli-config-webpack/dist/esm/production.js

import { ServiceType } from "@excitare/cli-types";
import chalk from "chalk";
import CopyWebpackPlugin from "copy-webpack-plugin";
import path from "path";
import TerserPlugin from "terser-webpack-plugin";
import { logDebugOutput } from "./debug";
import { createAliases } from "./fragments/aliases";
import { createDevtoolTemplates } from "./fragments/devtoolTemplate";
import { createNodeOptions } from "./fragments/nodeOptions";
import { createResolveOptions } from "./fragments/resolve";
import { createResolveLoader } from "./fragments/resolveLoader";
import { createDeduplicationAliases } from "./moduleDeduplication";
import { resolveModulePaths } from "./modulePaths";
import { createLoaders } from "./options/loaders";
import { createPlugins } from "./plugins";
export function resolveModule(moduleStr, configuration, extraPaths, dev = true, printFound = false) {
    const paths = [
        configuration.rootDir,
        configuration.context,
        path.dirname(configuration.entry),
        ...(extraPaths || [])
    ].filter(el => el != null);
    try {
        if (dev) {
            console.log(`Resolving ${chalk.gray(moduleStr)} in:\n${paths
                .filter((el) => Boolean(el))
                .map(el => " - " + path.resolve(el))
                .join("\n")}`);
        }
        const resolved = path.resolve(require.resolve(moduleStr + "/package.json", {
            paths: paths.filter((el) => Boolean(el))
        }));
        const { dir } = path.parse(resolved);
        if (printFound) {
            console.log(`  - ${chalk.gray(moduleStr)}: ${chalk.greenBright("found")} in directory ${chalk.cyan(dir)}`);
        }
        return path.resolve(dir);
    }
    catch (err) {
        if (printFound) {
            console.log(`  - ${chalk.gray(moduleStr)}: ${chalk.redBright("not found")}`);
        }
        return null;
    }
}
export function createProductionConfig(type, configuration) {
    console.log("  Module resolution");
    const modulePaths = resolveModulePaths(type, configuration, false);
    const { entry, entryNextDir, entryGraphqlPath, entryServiceDir, cliPath, graphqlPath, nextServerPath } = modulePaths;
    const alias = {
        ...createDeduplicationAliases(configuration, [configuration.entry, entryNextDir, entryServiceDir, entryGraphqlPath], configuration.bundleOptions.deduplication),
        ...createAliases(type, modulePaths, "./production")
    };
    logDebugOutput(modulePaths, type, configuration, alias, process.env.WEBPACK_BUNDLE_ANALYZE === "true");
    const externals = ["hiredis"];
    const flags = {
        minify: true,
        tiny: true
    };
    return {
        entry,
        devtool: "source-map",
        target: "node",
        mode: "production",
        resolve: createResolveOptions(alias),
        resolveLoader: createResolveLoader(modulePaths, configuration, process.env.WEBPACK_BUNDLE_ANALYZE === "true"),
        output: {
            path: configuration.outputDir,
            filename: configuration.outputName,
            pathinfo: true,
            futureEmitAssets: true,
            ...createDevtoolTemplates(configuration)
        },
        externals: [
            (context, request, callback) => {
                if (configuration.externals.includes(request) || externals.includes(request)) {
                    return callback(null, "commonjs " + request);
                }
                if (/config$/.test(request)) {
                    if (/next\/config$/.test(request) ||
                        /next-server\/config$/.test(request) ||
                        (/next-server/.test(context) && /\/runtime-config$/.test(request))) {
                        return callback(null, "commonjs " + "next-server/config");
                    }
                }
                if (/^react([\\//]|$)/.test(request)) {
                    // console.log("Matched react: %s", request);
                    return callback(null, "commonjs " + request);
                }
                if (/^react-dom([\\//]|$)/.test(request)) {
                    // console.log("Matched react-dom: %s", request);
                    return callback(null, "commonjs " + request);
                }
                callback();
            }
        ],
        node: createNodeOptions(type),
        module: {
            rules: createLoaders(cliPath, graphqlPath, configuration, true)
        },
        optimization: {
            concatenateModules: flags.tiny,
            namedModules: !flags.tiny,
            namedChunks: !flags.tiny,
            ...{
                moduleIds: "hashed"
            },
            minimizer: flags.minify
                ? [
                    new TerserPlugin({
                        cache: JSON.parse(process.env.terserDir),
                        parallel: false,
                        sourceMap: true,
                        terserOptions: {
                            ecma: 8,
                            compress: {
                                dead_code: true,
                                defaults: false,
                                unused: "keep_assign",
                                side_effects: true,
                                warnings: true
                            },
                            mangle: { ie8: false, keep_classnames: true, keep_fnames: true },
                            toplevel: false,
                            output: {
                                comments: false,
                                braces: true,
                                preamble: "// Code built by Excitare"
                            }
                        }
                    })
                ]
                : undefined,
            minimize: flags.minify,
            sideEffects: true,
            usedExports: true,
            providedExports: true,
            removeEmptyChunks: true,
            portableRecords: true
        },
        plugins: [
            // new WebpackDeepScopeAnalysisPlugin(),
            // new WebpackSourceMapSupport(),
            ...createPlugins(configuration, false, modulePaths),
            type === ServiceType.Frontend && nextServerPath != null
                ? new CopyWebpackPlugin([
                    {
                        // Used in normal deployments
                        from: path.join(nextServerPath, "./dist/lib/runtime-config.js"),
                        to: "./node_modules/next-server/config.js"
                    },
                    {
                        // Used only in cloud deployments
                        from: path.join(nextServerPath, "./dist/lib/runtime-config.js"),
                        to: "./next-server-config.js"
                    }
                ])
                : null,
            configuration.iconOptions != null
                ? new CopyWebpackPlugin([
                    {
                        from: "**/*",
                        context: configuration.iconOptions.inputDir,
                        to: configuration.iconOptions.outDir,
                        toType: "dir"
                    }
                ])
                : null
        ].filter(el => el != null)
    };
}
//# sourceMappingURL=production.js.map