pfr/ui/node_modules/compression-webpack-plugin/dist/index.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _crypto = _interopRequireDefault(require("crypto"));

var _url = _interopRequireDefault(require("url"));

var _path = _interopRequireDefault(require("path"));

var _webpack = _interopRequireWildcard(require("webpack"));

var _schemaUtils = _interopRequireDefault(require("schema-utils"));

var _options = _interopRequireDefault(require("./options.json"));

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*
  MIT License http://www.opensource.org/licenses/mit-license.php
  Author Tobias Koppers @sokra
*/
const {
  RawSource
} = // eslint-disable-next-line global-require
_webpack.default.sources || require('webpack-sources');

class CompressionPlugin {
  constructor(options = {}) {
    (0, _schemaUtils.default)(_options.default, options, {
      name: 'Compression Plugin',
      baseDataPath: 'options'
    });
    const {
      test,
      include,
      exclude,
      cache = true,
      algorithm = 'gzip',
      compressionOptions = {},
      filename = '[path].gz',
      threshold = 0,
      minRatio = 0.8,
      deleteOriginalAssets = false
    } = options;
    this.options = {
      test,
      include,
      exclude,
      cache,
      algorithm,
      compressionOptions,
      filename,
      threshold,
      minRatio,
      deleteOriginalAssets
    };
    this.algorithm = this.options.algorithm;
    this.compressionOptions = this.options.compressionOptions;

    if (typeof this.algorithm === 'string') {
      // eslint-disable-next-line global-require
      const zlib = require('zlib');

      this.algorithm = zlib[this.algorithm];

      if (!this.algorithm) {
        throw new Error(`Algorithm "${this.options.algorithm}" is not found in "zlib"`);
      }

      this.compressionOptions = { ...{
          level: 9
        },
        ...this.compressionOptions
      };
    }
  }

  static interpolateName(originalFilename, filename) {
    const parse = _url.default.parse(originalFilename);

    const {
      pathname
    } = parse;

    const {
      dir,
      name,
      ext
    } = _path.default.parse(pathname);

    const info = {
      file: originalFilename,
      path: pathname,
      dir: dir ? `${dir}/` : '',
      name,
      ext,
      query: parse.query ? `?${parse.query}` : ''
    };
    return typeof filename === 'function' ? filename(info) : filename.replace(/\[(file|path|query|dir|name|ext)]/g, (p0, p1) => info[p1]);
  } // eslint-disable-next-line consistent-return


  static getAsset(compilation, name) {
    // New API
    if (compilation.getAsset) {
      return compilation.getAsset(name);
    }

    if (compilation.assets[name]) {
      return {
        name,
        source: compilation.assets[name],
        info: {}
      };
    }
  }

  static emitAsset(compilation, name, source, assetInfo) {
    // New API
    if (compilation.emitAsset) {
      compilation.emitAsset(name, source, assetInfo);
    } // eslint-disable-next-line no-param-reassign


    compilation.assets[name] = source;
  }

  static updateAsset(compilation, name, newSource, assetInfo) {
    // New API
    if (compilation.updateAsset) {
      compilation.updateAsset(name, newSource, assetInfo);
    } // eslint-disable-next-line no-param-reassign


    compilation.assets[name] = newSource;
  }

  static deleteAsset(compilation, name) {
    // New API
    if (compilation.deleteAsset) {
      compilation.deleteAsset(name);
    } // eslint-disable-next-line no-param-reassign


    delete compilation.assets[name];
  }

  runCompressionAlgorithm(input) {
    return new Promise((resolve, reject) => {
      const {
        algorithm,
        compressionOptions
      } = this;
      algorithm(input, compressionOptions, (error, result) => {
        if (error) {
          return reject(error);
        }

        if (!Buffer.isBuffer(result)) {
          // eslint-disable-next-line no-param-reassign
          result = Buffer.from(result);
        }

        return resolve(result);
      });
    });
  }

  async compress(compilation, assets, CacheEngine, weakCache) {
    const assetNames = Object.keys(typeof assets === 'undefined' ? compilation.assets : assets).filter(assetName => // eslint-disable-next-line no-undefined
    _webpack.ModuleFilenameHelpers.matchObject.bind(undefined, this.options)(assetName));

    if (assetNames.length === 0) {
      return Promise.resolve();
    }

    const scheduledTasks = [];
    const cache = new CacheEngine(compilation, {
      cache: this.options.cache
    }, weakCache);

    for (const assetName of assetNames) {
      scheduledTasks.push((async () => {
        const {
          source,
          info
        } = CompressionPlugin.getAsset(compilation, assetName);

        if (info.compressed) {
          return;
        }

        let relatedName;

        if (typeof this.options.algorithm === 'function') {
          let filenameForRelatedName = this.options.filename;
          const index = filenameForRelatedName.lastIndexOf('?');

          if (index >= 0) {
            filenameForRelatedName = filenameForRelatedName.substr(0, index);
          }

          relatedName = `${_path.default.extname(filenameForRelatedName).slice(1)}ed`;
        } else {
          relatedName = `${this.options.algorithm}ed`;
        }

        if (info.related && info.related[relatedName]) {
          return;
        }

        let input = source.source();

        if (!Buffer.isBuffer(input)) {
          input = Buffer.from(input);
        }

        if (input.length < this.options.threshold) {
          return;
        }

        const cacheData = {
          source
        };

        if (CompressionPlugin.isWebpack4()) {
          cacheData.cacheKeys = {
            nodeVersion: process.version,
            // eslint-disable-next-line global-require
            'compression-webpack-plugin': require('../package.json').version,
            algorithm: this.algorithm,
            originalAlgorithm: this.options.algorithm,
            compressionOptions: this.compressionOptions,
            assetName,
            contentHash: _crypto.default.createHash('md4').update(input).digest('hex')
          };
        } else {
          cacheData.assetName = assetName;
        }

        let output = await cache.get(cacheData, {
          RawSource
        });

        if (!output) {
          try {
            output = new RawSource(await this.runCompressionAlgorithm(input));
          } catch (error) {
            compilation.errors.push(error);
            return;
          }

          cacheData.output = output;
          await cache.store(cacheData);
        }

        if (output.source().length / input.length > this.options.minRatio) {
          return;
        }

        const newAssetName = CompressionPlugin.interpolateName(assetName, this.options.filename);
        CompressionPlugin.emitAsset(compilation, newAssetName, output, {
          compressed: true
        });

        if (this.options.deleteOriginalAssets) {
          // eslint-disable-next-line no-param-reassign
          CompressionPlugin.deleteAsset(compilation, assetName);
        } else {
          CompressionPlugin.updateAsset(compilation, assetName, source, {
            related: {
              [relatedName]: newAssetName
            }
          });
        }
      })());
    }

    return Promise.all(scheduledTasks);
  }

  static isWebpack4() {
    return _webpack.version[0] === '4';
  }

  apply(compiler) {
    const pluginName = this.constructor.name;

    if (CompressionPlugin.isWebpack4()) {
      // eslint-disable-next-line global-require
      const CacheEngine = require('./Webpack4Cache').default;

      const weakCache = new WeakMap();
      compiler.hooks.emit.tapPromise({
        name: pluginName
      }, compilation => // eslint-disable-next-line no-undefined
      this.compress(compilation, undefined, CacheEngine, weakCache));
    } else {
      // eslint-disable-next-line global-require
      const CacheEngine = require('./Webpack5Cache').default;

      compiler.hooks.compilation.tap(pluginName, compilation => {
        // eslint-disable-next-line global-require
        const Compilation = require('webpack/lib/Compilation');

        compilation.hooks.processAssets.tapPromise({
          name: pluginName,
          stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
        }, assets => this.compress(compilation, assets, CacheEngine));
        compilation.hooks.statsPrinter.tap(pluginName, stats => {
          stats.hooks.print.for('asset.info.compressed').tap('compression-webpack-plugin', (compressed, {
            green,
            formatFlag
          }) => // eslint-disable-next-line no-undefined
          compressed ? green(formatFlag('compressed')) : undefined);
        });
      });
    }
  }

}

var _default = CompressionPlugin;
exports.default = _default;