asset-map-webpack-plugin/lib/index.js

"use strict";

var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };

var _slicedToArray = function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { var _arr = []; for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { _arr.push(_step.value); if (i && _arr.length === i) break; } return _arr; } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } };

var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };

var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };

var fs = _interopRequire(require("fs"));

var path = _interopRequire(require("path"));

var RequestShortener = _interopRequire(require("webpack/lib/RequestShortener"));

function ExtractAssets(modules, requestShortener, publicPath) {
  var emitted = false;
  var assets = modules.map(function (m) {
    var assets = Object.keys(m.assets || {});

    if (assets.length === 0) {
      return undefined;
    }

    var asset = assets[0];
    emitted = emitted || m.assets[asset].emitted;

    return {
      name: m.readableIdentifier(requestShortener),
      asset: asset
    };
  }).filter(function (m) {
    return m !== undefined;
  }).reduce(function (acc, m) {
    acc[m.name] = path.join(publicPath, m.asset);
    return acc;
  }, {});

  return [emitted, assets];
}

function ExtractChunks(chunks, publicPath) {
  var emitted = false;
  var chunks = chunks.map(function (c) {
    return {
      name: c.name,
      files: c.files.filter(function (f) {
        return path.extname(f) !== ".map";
      }).map(function (f) {
        return path.join(publicPath, f);
      })
    };
  }).reduce(function (acc, c) {
    acc[c.name] = c.files;
    return acc;
  }, {});

  return [emitted, chunks];
}

var AssetMapPlugin = (function () {
  /**
   * AssetMapPlugin
   *
   * @param {string} outputFile - Where to write the asset map file
   * @param {string} [relativeTo] - Key assets relative to this path, otherwise defaults to be relative to the directory where the outputFile is written
   */
  function AssetMapPlugin(outputFile, relativeTo) {
    _classCallCheck(this, AssetMapPlugin);

    this.outputFile = outputFile;
    this.relativeTo = relativeTo;
  }

  _prototypeProperties(AssetMapPlugin, null, {
    apply: {
      value: function apply(compiler) {
        var _this = this;
        compiler.plugin("done", function (stats) {
          var publicPath = stats.compilation.outputOptions.publicPath;
          var requestShortener = new RequestShortener(_this.relativeTo || path.dirname(_this.outputFile));

          var _ExtractAssets = ExtractAssets(stats.compilation.modules, requestShortener, publicPath);

          var _ExtractAssets2 = _slicedToArray(_ExtractAssets, 2);

          var assetsEmitted = _ExtractAssets2[0];
          var assets = _ExtractAssets2[1];
          var _ExtractChunks = ExtractChunks(stats.compilation.chunks, publicPath);

          var _ExtractChunks2 = _slicedToArray(_ExtractChunks, 2);

          var chunksEmitted = _ExtractChunks2[0];
          var chunks = _ExtractChunks2[1];


          if (assetsEmitted || chunksEmitted) {
            fs.writeFileSync(_this.outputFile, JSON.stringify({ assets: assets, chunks: chunks }));
          }
        });
      },
      writable: true,
      configurable: true
    }
  });

  return AssetMapPlugin;
})();

module.exports = AssetMapPlugin;