index.js

var fs = require('fs');

var ExcludeRegexp;
var useAsLoader;
var Bundles;
var includeFilePaths;
var Encoding;
var AllowDuplicatesInBundle;
var printProgress;
var CommentTags = { Start: '/* ', End: ' */' };
var FileEnding;

function MergeIntoFile(options) {
  ExcludeRegexp = options.excludedFilenames || null;
  useAsLoader = options.useAsLoader || false;
  includeFilePaths = options.includeFilePathComments || false;
  Encoding = options.readEncoding || null;
  AllowDuplicatesInBundle = options.allowDuplicatesInBundle || false;
  Bundles = options.bundles;
  printProgress = options.printProgress || false;
  FileEnding = options.fileEnding || '\n\n';

  if (includeFilePaths) CommentTags = options.commentTags || CommentTags;

  this.options = options;
}

function isExcluded(aString, currentBundleOptions) {
  var isIncluded =
    currentBundleOptions && currentBundleOptions.match
      ? currentBundleOptions.match.test(aString)
      : true;

  return ExcludeRegexp && isIncluded
    ? ExcludeRegexp.some(function(exp) {
        return exp.test(aString);
      })
    : !isIncluded;
}

// List all files in a directory in Node.js recursively in a synchronous fashion
var walkSync = function(dir, filelist, ext, currentBundleOptions) {
  var path = path || require('path');
  var fs = fs || require('fs');
  var files = fs.readdirSync(dir);
  filelist = filelist || [];
  files.forEach(function(file) {
    if (fs.statSync(path.join(dir, file)).isDirectory()) {
      filelist = walkSync(
        path.join(dir, file),
        filelist,
        ext,
        currentBundleOptions,
      );
    } else {
      if (
        file.match(new RegExp('.' + ext + '$')) &&
        !isExcluded(file, currentBundleOptions)
      )
        filelist.push(path.join(dir, file));
    }
  });
  return filelist;
};

var RelativeRegexp = /(.*?)\*.(.*?)$/;
var BeenHere = {};
function mergeFiles(
  list,
  currentBundleOptions,
  FileExt,
  BeenHere,
  callback,
  ind,
) {
  if (!ind) ind = 0;
  if (!AllowDuplicatesInBundle && list[ind] && BeenHere[list[ind]]) ind++;
  else BeenHere[list] = 1;

  // Recursive ending conditions
  if (typeof list == 'string') {
    if (ind > 0) {
      return callback(null, '');
    }
  } else if (ind >= list.length) {
    return callback(null, '');
  }

  // Parse a folder for it's files dynamically
  if (
    FileExt == null &&
    (currentBundleOptions ||
      typeof list == 'string' ||
      typeof list[ind] == 'string')
  ) {
    var useThisString = currentBundleOptions
      ? currentBundleOptions.path
      : typeof list == 'string'
      ? list
      : list[ind];
    var Matched = useThisString.match(RelativeRegexp);
    if (Matched) {
      FileExt = Matched[2];

      // Merge the newly found files into the list of things to deal with
      list = walkSync(Matched[1], [], FileExt, currentBundleOptions).concat(
        list.slice(ind + 1),
      );
      ind = 0;
      currentBundleOptions = null; // Clear out the options to keep on processing
    }
  }

  var curfile = currentBundleOptions
    ? currentBundleOptions.path
    : typeof list == 'string'
    ? list
    : list[ind];

  if (printProgress)
    console.log(
      'Bundling: ' + curfile + '[' + (ind + 1) + '/' + list.length + ']',
    );

  if (typeof curfile == 'undefined') return callback(null, '');

  fs.readFile(curfile, Encoding, (err, body) => {
    if (err) return callback(err);

    // Add the debug tags to see what file is what
    if (includeFilePaths)
      body = CommentTags.Start + curfile + CommentTags.End + '\n' + body;

    var nextOptions =
      list[ind + 1] && list[ind + 1].path ? list[ind + 1] : null;

    mergeFiles(
      list,
      nextOptions,
      FileExt,
      BeenHere,
      (err, otherFilesBody) => {
        if (err) return callback(err);
        callback(null, body + FileEnding + otherFilesBody);
      },
      ind + 1,
    );
  });
}

MergeIntoFile.prototype.apply = function(compiler) {
  var options = this.options;
  compiler.hooks.emit.tapAsync('Visualizer', (compilation, callback) => {
    var count = 0;
    var file2createCnt = 0;
    Bundles.forEach(function(filename) {
      if (printProgress) console.log('Starting to bundle: ' + filename);

      var files = options[filename];
      var BundleMe;
      var currentBundlePartOptions;

      if (typeof files[0] == 'string') {
        //BundleMe = files[0];
        currentBundlePartOptions = null;
      } else {
        //BundleMe = files[0].path;
        currentBundlePartOptions = files[0];
      }

      // files = [./bin/file1.txt
      //        ./bin/*.txt]
      file2createCnt++;
      (function(filenaname2create) {
        mergeFiles(
          files,
          currentBundlePartOptions,
          null,
          {},
          (err, content) => {
            if (err) return callback(err);
            compilation.assets[filenaname2create] = {
              source: function() {
                return content;
              },
              size: function() {
                return content.length;
              },
            };
            count++;
            if (file2createCnt === count) {
              callback();
            }
          },
        );
      })(filename);
    });
  });
};

module.exports = MergeIntoFile;