@aofl/aofljs-cli/src/build-app/index.js

const chalk = require('chalk');
const path = require('path');
const fse = require('fs-extra');
const copy = require('recursive-copy');
const through = require('through2');
const build = require('../build');
const translate = require('../translate');

const afterLastSlashRegex = new RegExp(`\\${path.sep}*([^\\${path.sep}]*)$`);
/**
 * Submodule's relative paths to specific files
 * @type {String[]}
 */
const MARKET_ARRAY = [
  {excludePrefix: '**', path: 'index.html'},
  // {excludePrefix: '**', path: '__build.js'},
  // {excludePrefix: '**', path: 'js/main.js'},
  // {excludePrefix: '**', path: 'js/config/local-api-config.json'},
  // {excludePrefix: '**', path: 'js/config/stage-api-config.json'},
  // {excludePrefix: '**', path: 'js/config/state-routes.js'},
];
const MARKET_FILES = MARKET_ARRAY.map((item)=> item.path);
const FILTER = [
  '**/*',
  '!**/.git/**',
  '!**/.git*',
  '!**/*.spec.js',
  '!**/node_modules/**',
  '!**/bower_components/**',
  '!**/karma.conf.js',
  '!**/main.karma.js',
  '!**/*.md'
];
let replacer = (output)=> (match, p1) => p1 + output;

let transformFiles = {
  'main.js': (_str, src, output) => {
    let pathRegex = new RegExp('(.*' + src + '.*:.*)(' + src + ')', 'g');
    let appIdRegex = new RegExp('(.*applicationId.*)(' + src + ')', 'g');

    return _str
    .replace(pathRegex, replacer(output))
    .replace(appIdRegex, replacer(output));
  },
  '__build.js': (_str, src, output) => {
    let pathRegex = new RegExp('(:.*)(' + src + ')', 'g');

    return _str
    .replace(pathRegex, replacer(output));
  },
  'index.html': (_str, src, output) => {
    let pathRegex = new RegExp('(.*' + src + '.*:.*)(' + src + ')("|\').*', 'g');
    let appIdRegex = new RegExp('(.*applicationId.*)(' + src + ')', 'g');
    let selfRegex = new RegExp(src, 'g');
    let mainjsRegex = /(data-main=".*?)(\.min)?(")/;

    let out = _str
    .replace(pathRegex, (match, p1, p2, p3) => {
      return p1 + output + p3 + ',\n' + match.replace(selfRegex, output)
    })
    .replace(appIdRegex, replacer(output))
    .replace(mainjsRegex, '$1.min$3');

    return out;
  }
};

module.exports = function buildApp(_args, _outputPath, _configPath, _market = '', _regexp = [], _verbose = false) {
  const IS_MARKET = _market !== '' && _market;
  let apps = [];
  let filters = FILTER.concat(_regexp);

  if (typeof _configPath !== 'undefined') {
    let configPath = path.resolve(_configPath);
    let config = require(configPath);
    if (_args.length > 0) {
      apps = config.apps.filter(element => _args.some(e => e === element.name));
    } else {
      apps = config.apps;
    }

    apps = apps.map(element => {
      element.src = path.resolve(element.src);
      element.output = path.resolve(element.output);
      return element;
    });
  } else if (typeof _outputPath !== 'undefined' && _args.length > 0) {
    let outputPath = path.resolve(_outputPath);
    let srcPath = path.resolve(_args[0]);

    apps.push({
      src: srcPath,
      output: outputPath
    });
  }

  apps.forEach((element) => {
    let market = element.market || _market;
    const HAS_MARKET = market || IS_MARKET;
    let srcPath = path.normalize(element.src);
    let outputPath = path.normalize(element.output);
    let srcDirname = srcPath.match(afterLastSlashRegex)[1];
    let outputDirname = outputPath.match(afterLastSlashRegex)[1];
    let filter = filters;
    let replace = `-${market}.`;
    let getCleanName = (fileName)=> fileName.replace(replace, '.');

    if (HAS_MARKET) {
      filter = filters.concat(MARKET_ARRAY.map((item)=>
      path.join(`!${item.excludePrefix}`, item.path)));
    }

    fse.emptyDirSync(outputPath);
    copy(srcPath, outputPath, {
      overwrite: true,
      dot: true,
      filter: filter,
      rename: function(filePath) {
        let fileName = path.basename(filePath);
        let cleanName = getCleanName(fileName);
        let dirName = path.dirname(filePath);
        let clearPath = path.join(dirName, cleanName);

        if (!(HAS_MARKET && fileName.includes(replace) &&
          (MARKET_FILES.includes(clearPath) || MARKET_FILES.includes(cleanName)
        ))) {
          return filePath;
        }

        return clearPath;
      },
      transform: (_src, _dest, _stats) => {
        let fileName = path.basename(_src);
        let cleanName = getCleanName(fileName);

        if (typeof transformFiles[cleanName] !== 'function') {
          return null;
        }
        return through((chunk, enc, done) => {
          let output = chunk.toString();
          output = transformFiles[cleanName](output, srcDirname, outputDirname);
          done(null, output);
        });
      }
    }).then((_results) => {
      console.info(chalk.magenta(_results.length + ' file(s) copied to ',
      outputPath));

      translate
      .replaceText([outputPath])
      .then(() => build([outputPath], true, market, _verbose))
      .catch(() => {
        console.log(chalk.red(outputPath + ': translation failed'));
        build([outputPath], true, market);
      });
      /** @todo: translate */
    }).catch(_err => {
      console.error(_err);
      throw _err;
    });
  });
};