webpack-uglify-js-plugin/utils/ModuleFilenameHelpers.js

Incremental Uglify JS for webpack

/*
  MIT License http://www.opensource.org/licenses/mit-license.php
  Author Tobias Koppers @sokra
*/
var ModuleFilenameHelpers = exports;

ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE = /\[all-?loaders\]\[resource\]/gi;
ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]";
ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi;
ModuleFilenameHelpers.RESOURCE = "[resource]";
ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi;
ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]";
ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH = /\[abs(olute)?-?resource-?path\]/gi;
ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]";
ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi;
ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]";
ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi;
ModuleFilenameHelpers.LOADERS = "[loaders]";
ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi;
ModuleFilenameHelpers.QUERY = "[query]";
ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi;
ModuleFilenameHelpers.ID = "[id]";
ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi;
ModuleFilenameHelpers.HASH = "[hash]";
ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;

function getAfter(str, token) {
  var idx = str.indexOf(token);
  return idx < 0 ? "" : str.substr(idx);
}

function getBefore(str, token) {
  var idx = str.lastIndexOf(token);
  return idx < 0 ? "" : str.substr(0, idx);
}

function getHash(str) {
  var hash = require("crypto").createHash("md5");
  hash.update(str);
  return hash.digest("hex").substr(0, 4);
}

function asRegExp(test) {
  if(typeof test === "string") test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
  return test;
}

ModuleFilenameHelpers.createFilename = function createFilename(module, moduleFilenameTemplate, requestShortener) {
  if(!module) module = "";
  if(typeof module === "string") {
    var shortIdentifier = requestShortener.shorten(module);
    var identifier = shortIdentifier;
    var moduleId = "";
    var absoluteResourcePath = module.split("!").pop();
    var hash = getHash(identifier);
  } else {
    var shortIdentifier = module.readableIdentifier(requestShortener);
    var identifier = requestShortener.shorten(module.identifier());
    var moduleId = module.id;
    var absoluteResourcePath = module.resourcePath || module.identifier().split("!").pop();
    var hash = getHash(identifier);
  }
  var resource = shortIdentifier.split("!").pop();
  var loaders = getBefore(shortIdentifier, "!");
  var allLoaders = getBefore(identifier, "!");
  var query = getAfter(resource, "?");
  var resourcePath = resource.substr(0, resource.length - query.length);
  if(typeof moduleFilenameTemplate === "function") {
    return moduleFilenameTemplate({
      identifier: identifier,
      shortIdentifier: shortIdentifier,
      resource: resource,
      resourcePath: resourcePath,
      absoluteResourcePath: absoluteResourcePath,
      allLoaders: allLoaders,
      query: query,
      moduleId: moduleId,
      hash: hash
    });
  }
  return moduleFilenameTemplate
    .replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, identifier)
    .replace(ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE, shortIdentifier)
    .replace(ModuleFilenameHelpers.REGEXP_RESOURCE, resource)
    .replace(ModuleFilenameHelpers.REGEXP_RESOURCE_PATH, resourcePath)
    .replace(ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH, absoluteResourcePath)
    .replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS, allLoaders)
    .replace(ModuleFilenameHelpers.REGEXP_LOADERS, loaders)
    .replace(ModuleFilenameHelpers.REGEXP_QUERY, query)
    .replace(ModuleFilenameHelpers.REGEXP_ID, moduleId)
    .replace(ModuleFilenameHelpers.REGEXP_HASH, hash);
};

ModuleFilenameHelpers.createFooter = function createFooter(module, requestShortener) {
  if(!module) module = "";
  if(typeof module === "string") {
    return [
      "/** WEBPACK FOOTER **",
      " ** " + requestShortener.shorten(module),
      " **/"
    ].join("\n");
  } else {
    return [
      "/*****************",
      " ** WEBPACK FOOTER",
      " ** " + module.readableIdentifier(requestShortener),
      " ** module id = " + module.id,
      " ** module chunks = " + module.chunks.map(function(c) {
        return c.id;
      }).join(" "),
      " **/"
    ].join("\n");
  }
};

ModuleFilenameHelpers.replaceDuplicates = function replaceDuplicates(array, fn, comparator) {
  var countMap = {};
  var posMap = {};
  array.forEach(function(item, idx) {
    countMap[item] = (countMap[item] || []);
    countMap[item].push(idx);
    posMap[item] = 0;
  });
  if(comparator) {
    Object.keys(countMap).forEach(function(item) {
      countMap[item].sort(comparator);
    });
  }
  return array.map(function(item, i) {
    if(countMap[item].length > 1) {
      if(comparator && countMap[item][0] === i)
        return item;
      return fn(item, i, posMap[item]++);
    } else return item;
  });
};

ModuleFilenameHelpers.matchPart = function matchPart(str, test) {
  if(!test) return true;
  test = asRegExp(test);
  if(Array.isArray(test)) {
    return test.map(asRegExp).filter(function(regExp) {
      return regExp.test(str);
    }).length > 0;
  } else {
    return test.test(str);
  }
};

ModuleFilenameHelpers.matchObject = function matchObject(obj, str) {
  if(obj.test)
    if(!ModuleFilenameHelpers.matchPart(str, obj.test)) return false;
  if(obj.include)
    if(!ModuleFilenameHelpers.matchPart(str, obj.include)) return false;
  if(obj.exclude)
    if(ModuleFilenameHelpers.matchPart(str, obj.exclude)) return false;
  return true;
};