@mindbox/frontend/build/create-inject-mapping.js

"use strict";

const fs = require("fs");
const path = require("path");
var program = require("commander");

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

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
        );
};

const get_mapping = (partsFile, assetsFile, mappingTemplate) => {
    const result = [];
    partsFile.forEach(f => {
        const partsProvider = require(`../${f}`);
        const part = partsProvider();
        part.entries.forEach(e => {
            const sourceDirectory = path.join(path.dirname(f), e.outputPath);
            const fileName = `${e.name}.js`;
            result.push({
                sourceFile: path.join(sourceDirectory, fileName),
                destinationFile: path.join(
                    mappingTemplate.parts[part.name].entriesDist,
                    fileName
                )
            });
        });

        if (part.commonChunk !== undefined) {
            const fileName = `${path.parse(part.commonChunk).base}.js`;
            result.push({
                sourceFile: path.join(
                    path.dirname(f),
                    path.dirname(part.commonChunk),
                    fileName
                ),
                destinationFile: path.join(
                    mappingTemplate.parts[part.name].commonChunkDist,
                    fileName
                )
            });
        }

        if (part.libraries !== undefined) {
            part.libraries.forEach(l => {
                const sourceDirectory = path.join(
                    path.dirname(f),
                    l.outputPath
                );
                const fileName = `${l.name}.js`;
                result.push({
                    sourceFile: path.join(sourceDirectory, fileName),
                    destinationFile: path.join(
                        mappingTemplate.parts[part.name].librariesDist,
                        fileName
                    )
                });
            });
        }
    });
    assetsFile.forEach(f => {
        const assetsProvider = require(`../${f}`);
        const assets = assetsProvider();
        assets.forEach(a => {
            const sourceDirectory = path.join(
                path.dirname(f),
                a.destinationDirectory
            );
            a.sourceFiles.forEach(s => {
                const fileName = path.basename(s);
                const sourceFile = path.join(sourceDirectory, fileName);

                if (!mappingTemplate.assets[a.name])
                    throw Error(`Asset not found`);

                result.push({
                    sourceFile: sourceFile,
                    destinationFile: path.join(
                        mappingTemplate.assets[a.name].destinationDirectory,
                        fileName
                    )
                });
            });
        });
    });

    const sourceDirectory = path.join("dist", "content", "localization");
    fs.readdirSync(sourceDirectory).forEach(f => {
        const fileName = path.parse(f).base;
        result.push({
            sourceFile: path.join(sourceDirectory, f),
            destinationFile: path.join(
                mappingTemplate.localizationDist,
                fileName
            )
        });
    });

    return result;
};

const generate_reverse_mapping = (templatePath, projectName) => {
    if (!program.template) throw Error("Template is not specified");

    const mappingTemplate = require(resolvePathToAbsolute(
        solutionDir,
        templatePath
    ));
    const projects = require("./projects.json");
    const profiles = {};

    if (projectName && !projects.parts[projectName])
        throw Error(`Profile ${projectName} is not found`);

    for (const property in projects.parts) {
        if (!projectName || property == projectName) {
            const parts = projects.parts[property];
            profiles[property] = { parts: parts, assets: [] };
        }
    }

    for (const property in projects.assets) {
        const assets = projects.assets[property];
        if (!projectName || (assets && property == projectName)) {
            if (profiles[property] !== undefined) {
                profiles[property] = {
                    parts: profiles[property].parts,
                    assets: assets
                };
            } else {
                profiles[property] = { parts: [], assets: assets };
            }
        }
    }

    for (const profile in profiles) {
        profiles[profile] = get_mapping(
            profiles[profile].parts,
            profiles[profile].assets,
            mappingTemplate
        );
    }

    fs.writeFileSync(
        path.join(solutionDir, "directcrm-modules-map.json"),
        JSON.stringify(profiles, {}, 4)
    );
};

program
    .option("-t, --template <file>", "Template file path")
    .option(
        "-p, --profile [name]",
        "Installation profile name, can be one of the following: `tracker`, `administration`, `directCrm`, `nexus` etc." +
            "By default inject mapping would be created for all profiles from project.json"
    )
    .parse(process.argv);

generate_reverse_mapping(program.template, program.profile);