first commit

node_modules/copy-webpack-plugin/dist/cjs.js

@@ -0,0 +1,5 @@
+"use strict";
+
+const plugin = require('./index');
+
+module.exports = plugin.default;

node_modules/copy-webpack-plugin/dist/index.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _webpackLog = _interopRequireDefault(require("webpack-log"));
+
+var _preProcessPattern = _interopRequireDefault(require("./preProcessPattern"));
+
+var _processPattern = _interopRequireDefault(require("./processPattern"));
+
+var _postProcessPattern = _interopRequireDefault(require("./postProcessPattern"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class CopyPlugin {
+  constructor(patterns = [], options = {}) {
+    if (!Array.isArray(patterns)) {
+      throw new Error('[copy-webpack-plugin] patterns must be an array');
+    }
+
+    this.patterns = patterns;
+    this.options = options;
+  }
+
+  apply(compiler) {
+    const fileDependencies = new Set();
+    const contextDependencies = new Set();
+    const written = {};
+    let context;
+
+    if (!this.options.context) {
+      ({
+        context
+      } = compiler.options);
+    } else if (!_path.default.isAbsolute(this.options.context)) {
+      context = _path.default.join(compiler.options.context, this.options.context);
+    } else {
+      ({
+        context
+      } = this.options);
+    }
+
+    const logger = (0, _webpackLog.default)({
+      name: 'copy-webpack-plugin',
+      level: this.options.logLevel || 'warn'
+    });
+    const plugin = {
+      name: 'CopyPlugin'
+    };
+    compiler.hooks.emit.tapAsync(plugin, (compilation, callback) => {
+      logger.debug('starting emit');
+      const globalRef = {
+        logger,
+        compilation,
+        written,
+        fileDependencies,
+        contextDependencies,
+        context,
+        inputFileSystem: compiler.inputFileSystem,
+        output: compiler.options.output.path,
+        ignore: this.options.ignore || [],
+        copyUnmodified: this.options.copyUnmodified,
+        concurrency: this.options.concurrency
+      };
+
+      if (globalRef.output === '/' && compiler.options.devServer && compiler.options.devServer.outputPath) {
+        globalRef.output = compiler.options.devServer.outputPath;
+      }
+
+      const {
+        patterns
+      } = this;
+      Promise.all(patterns.map(pattern => Promise.resolve().then(() => (0, _preProcessPattern.default)(globalRef, pattern)) // Every source (from) is assumed to exist here
+      // eslint-disable-next-line no-shadow
+      .then(pattern => (0, _processPattern.default)(globalRef, pattern).then(files => {
+        if (!files) {
+          return Promise.resolve();
+        }
+
+        return Promise.all(files.filter(Boolean).map(file => (0, _postProcessPattern.default)(globalRef, pattern, file)));
+      })))).catch(error => {
+        compilation.errors.push(error);
+      }).then(() => {
+        logger.debug('finishing emit');
+        callback();
+      });
+    });
+    compiler.hooks.afterEmit.tapAsync(plugin, (compilation, callback) => {
+      logger.debug('starting after-emit'); // Add file dependencies
+
+      if ("addAll" in compilation.fileDependencies) {
+        compilation.fileDependencies.addAll(fileDependencies);
+      } else {
+        for (const fileDependency of fileDependencies) {
+          compilation.fileDependencies.add(fileDependency);
+        }
+      } // Add context dependencies
+
+
+      if ("addAll" in compilation.contextDependencies) {
+        compilation.contextDependencies.addAll(contextDependencies);
+      } else {
+        for (const contextDependency of contextDependencies) {
+          compilation.contextDependencies.add(contextDependency);
+        }
+      }
+
+      logger.debug('finishing after-emit');
+      callback();
+    });
+  }
+
+}
+
+var _default = CopyPlugin;
+exports.default = _default;

node_modules/copy-webpack-plugin/dist/postProcessPattern.js

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = postProcessPattern;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _os = _interopRequireDefault(require("os"));
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+var _loaderUtils = _interopRequireDefault(require("loader-utils"));
+
+var _cacache = _interopRequireDefault(require("cacache"));
+
+var _serializeJavascript = _interopRequireDefault(require("serialize-javascript"));
+
+var _findCacheDir = _interopRequireDefault(require("find-cache-dir"));
+
+var _normalizePath = _interopRequireDefault(require("normalize-path"));
+
+var _package = require("../package.json");
+
+var _promisify = require("./utils/promisify");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable no-param-reassign */
+function postProcessPattern(globalRef, pattern, file) {
+  const {
+    logger,
+    compilation,
+    fileDependencies,
+    written,
+    inputFileSystem,
+    copyUnmodified
+  } = globalRef;
+  logger.debug(`getting stats for '${file.absoluteFrom}' to write to assets`);
+  const getStats = pattern.stats ? Promise.resolve().then(() => pattern.stats) : (0, _promisify.stat)(inputFileSystem, file.absoluteFrom);
+  return getStats.then(stats => {
+    // We don't write empty directories
+    if (stats.isDirectory()) {
+      logger.debug(`skipping '${file.absoluteFrom}' because it is empty directory`);
+      return Promise.resolve();
+    } // If this came from a glob, add it to the file watchlist
+
+
+    if (pattern.fromType === 'glob') {
+      fileDependencies.add(file.absoluteFrom);
+    }
+
+    logger.debug(`reading '${file.absoluteFrom}' to write to assets`);
+    return (0, _promisify.readFile)(inputFileSystem, file.absoluteFrom).then(content => {
+      if (pattern.transform) {
+        logger.info(`transforming content for '${file.absoluteFrom}'`); // eslint-disable-next-line no-shadow
+
+        const transform = (content, absoluteFrom) => pattern.transform(content, absoluteFrom);
+
+        if (pattern.cache) {
+          if (!globalRef.cacheDir) {
+            globalRef.cacheDir = (0, _findCacheDir.default)({
+              name: 'copy-webpack-plugin'
+            }) || _os.default.tmpdir();
+          }
+
+          const cacheKey = pattern.cache.key ? pattern.cache.key : (0, _serializeJavascript.default)({
+            name: _package.name,
+            version: _package.version,
+            pattern,
+            hash: _crypto.default.createHash('md4').update(content).digest('hex')
+          });
+          return _cacache.default.get(globalRef.cacheDir, cacheKey).then(result => {
+            logger.debug(`getting cached transformation for '${file.absoluteFrom}'`);
+            return result.data;
+          }, () => Promise.resolve().then(() => transform(content, file.absoluteFrom)) // eslint-disable-next-line no-shadow
+          .then(content => {
+            logger.debug(`caching transformation for '${file.absoluteFrom}'`);
+            return _cacache.default.put(globalRef.cacheDir, cacheKey, content).then(() => content);
+          }));
+        }
+
+        content = transform(content, file.absoluteFrom);
+      }
+
+      return content;
+    }).then(content => {
+      if (pattern.toType === 'template') {
+        logger.info(`interpolating template '${file.webpackTo}' for '${file.relativeFrom}'`); // If it doesn't have an extension, remove it from the pattern
+        // ie. [name].[ext] or [name][ext] both become [name]
+
+        if (!_path.default.extname(file.relativeFrom)) {
+          file.webpackTo = file.webpackTo.replace(/\.?\[ext\]/g, '');
+        }
+
+        file.webpackTo = _loaderUtils.default.interpolateName({
+          resourcePath: file.absoluteFrom
+        }, file.webpackTo, {
+          content,
+          regExp: file.webpackToRegExp,
+          context: pattern.context
+        }); // Bug in `loader-utils`, package convert `\\` to `/`, need fix in loader-utils
+
+        file.webpackTo = _path.default.normalize(file.webpackTo);
+      }
+
+      return content;
+    }).then(content => {
+      if (pattern.transformPath) {
+        logger.info(`transforming path '${file.webpackTo}' for '${file.absoluteFrom}'`);
+        return Promise.resolve().then(() => pattern.transformPath(file.webpackTo, file.absoluteFrom)).then(newPath => {
+          file.webpackTo = newPath;
+          return content;
+        });
+      }
+
+      return content;
+    }).then(content => {
+      const hash = _loaderUtils.default.getHashDigest(content);
+
+      const targetPath = (0, _normalizePath.default)(file.webpackTo);
+      const targetAbsolutePath = (0, _normalizePath.default)(file.absoluteFrom);
+
+      if (!copyUnmodified && written[targetPath] && written[targetPath][targetAbsolutePath] && written[targetPath][targetAbsolutePath] === hash) {
+        logger.info(`skipping '${file.webpackTo}', because content hasn't changed`);
+        return;
+      }
+
+      logger.debug(`adding '${file.webpackTo}' for tracking content changes`);
+
+      if (!written[targetPath]) {
+        written[targetPath] = {};
+      }
+
+      written[targetPath][targetAbsolutePath] = hash;
+
+      if (compilation.assets[targetPath] && !file.force) {
+        logger.info(`skipping '${file.webpackTo}', because it already exists`);
+        return;
+      }
+
+      logger.info(`writing '${file.webpackTo}' to compilation assets from '${file.absoluteFrom}'`);
+      compilation.assets[targetPath] = {
+        size() {
+          return stats.size;
+        },
+
+        source() {
+          return content;
+        }
+
+      };
+    });
+  });
+}

node_modules/copy-webpack-plugin/dist/preProcessPattern.js

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = preProcessPattern;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _isGlob = _interopRequireDefault(require("is-glob"));
+
+var _globParent = _interopRequireDefault(require("glob-parent"));
+
+var _normalize = _interopRequireDefault(require("./utils/normalize"));
+
+var _isTemplateLike = _interopRequireDefault(require("./utils/isTemplateLike"));
+
+var _isObject = _interopRequireDefault(require("./utils/isObject"));
+
+var _promisify = require("./utils/promisify");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable no-param-reassign */
+function preProcessPattern(globalRef, pattern) {
+  const {
+    logger,
+    context,
+    inputFileSystem,
+    fileDependencies,
+    contextDependencies,
+    compilation
+  } = globalRef;
+  pattern = typeof pattern === 'string' ? {
+    from: pattern
+  } : Object.assign({}, pattern);
+
+  if (pattern.from === '') {
+    const message = 'path "from" cannot be empty string';
+    logger.error(message);
+    compilation.errors.push(new Error(message));
+  }
+
+  pattern.to = pattern.to || '';
+  pattern.context = pattern.context || context;
+
+  if (!_path.default.isAbsolute(pattern.context)) {
+    pattern.context = _path.default.join(context, pattern.context);
+  }
+
+  const isFromGlobPatten = (0, _isObject.default)(pattern.from) && pattern.from.glob; // Todo remove this in next major
+
+  const isToDirectory = _path.default.extname(pattern.to) === '' || pattern.to.slice(-1) === _path.default.sep; // Normalize paths
+
+
+  pattern.from = isFromGlobPatten ? pattern.from : _path.default.normalize(pattern.from);
+  pattern.context = _path.default.normalize(pattern.context);
+  pattern.to = _path.default.normalize(pattern.to);
+  pattern.ignore = globalRef.ignore.concat(pattern.ignore || []);
+  logger.debug(`processing from: '${pattern.from}' to: '${pattern.to}'`);
+
+  switch (true) {
+    // if toType already exists
+    case !!pattern.toType:
+      break;
+
+    case (0, _isTemplateLike.default)(pattern.to):
+      pattern.toType = 'template';
+      break;
+
+    case isToDirectory:
+      pattern.toType = 'dir';
+      break;
+
+    default:
+      pattern.toType = 'file';
+  } // If we know it's a glob, then bail early
+
+
+  if (isFromGlobPatten) {
+    logger.debug(`determined '${pattern.absoluteFrom}' is a glob`);
+    pattern.fromType = 'glob';
+    const globOptions = Object.assign({}, pattern.from);
+    delete globOptions.glob;
+    pattern.glob = (0, _normalize.default)(pattern.context, pattern.from.glob);
+    pattern.globOptions = globOptions;
+    pattern.absoluteFrom = _path.default.resolve(pattern.context, pattern.from.glob);
+    return Promise.resolve(pattern);
+  }
+
+  if (_path.default.isAbsolute(pattern.from)) {
+    pattern.absoluteFrom = pattern.from;
+  } else {
+    pattern.absoluteFrom = _path.default.resolve(pattern.context, pattern.from);
+  }
+
+  logger.debug(`determined '${pattern.from}' to be read from '${pattern.absoluteFrom}'`);
+
+  const noStatsHandler = () => {
+    // If from doesn't appear to be a glob, then log a warning
+    if ((0, _isGlob.default)(pattern.from) || pattern.from.includes('*')) {
+      logger.debug(`determined '${pattern.absoluteFrom}' is a glob`);
+      pattern.fromType = 'glob';
+      pattern.glob = (0, _normalize.default)(pattern.context, pattern.from); // We need to add context directory as dependencies to avoid problems when new files added in directories
+      // when we already in watch mode and this directories are not in context dependencies
+      // `glob-parent` always return `/` we need normalize path
+
+      contextDependencies.add(_path.default.normalize((0, _globParent.default)(pattern.absoluteFrom)));
+    } else {
+      const newWarning = new Error(`unable to locate '${pattern.from}' at '${pattern.absoluteFrom}'`);
+      const hasWarning = compilation.warnings.some( // eslint-disable-next-line no-shadow
+      warning => warning.message === newWarning.message); // Only display the same message once
+
+      if (!hasWarning) {
+        logger.warn(newWarning.message);
+        compilation.warnings.push(newWarning);
+      }
+
+      pattern.fromType = 'nonexistent';
+    }
+  };
+
+  logger.debug(`getting stats for '${pattern.absoluteFrom}' to determinate 'fromType'`);
+  return (0, _promisify.stat)(inputFileSystem, pattern.absoluteFrom).catch(() => noStatsHandler()).then(stats => {
+    if (!stats) {
+      noStatsHandler();
+      return pattern;
+    }
+
+    if (stats.isDirectory()) {
+      logger.debug(`determined '${pattern.absoluteFrom}' is a directory`);
+      contextDependencies.add(pattern.absoluteFrom);
+      pattern.fromType = 'dir';
+      pattern.context = pattern.absoluteFrom;
+      pattern.glob = (0, _normalize.default)(pattern.absoluteFrom, '**/*');
+      pattern.absoluteFrom = _path.default.join(pattern.absoluteFrom, '**/*');
+      pattern.globOptions = {
+        dot: true
+      };
+    } else if (stats.isFile()) {
+      logger.debug(`determined '${pattern.absoluteFrom}' is a file`);
+      fileDependencies.add(pattern.absoluteFrom);
+      pattern.stats = stats;
+      pattern.fromType = 'file';
+      pattern.context = _path.default.dirname(pattern.absoluteFrom);
+      pattern.glob = (0, _normalize.default)(pattern.absoluteFrom);
+      pattern.globOptions = {
+        dot: true
+      };
+    } else if (!pattern.fromType) {
+      logger.warn(`unrecognized file type for ${pattern.from}`);
+    }
+
+    return pattern;
+  });
+}

node_modules/copy-webpack-plugin/dist/processPattern.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = processPattern;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _globby = _interopRequireDefault(require("globby"));
+
+var _pLimit = _interopRequireDefault(require("p-limit"));
+
+var _minimatch = _interopRequireDefault(require("minimatch"));
+
+var _isObject = _interopRequireDefault(require("./utils/isObject"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function processPattern(globalRef, pattern) {
+  const {
+    logger,
+    output,
+    concurrency,
+    compilation
+  } = globalRef;
+  const globOptions = Object.assign({
+    cwd: pattern.context,
+    follow: true // Todo in next major release
+    // dot: false
+
+  }, pattern.globOptions || {});
+
+  if (pattern.fromType === 'nonexistent') {
+    return Promise.resolve();
+  }
+
+  const limit = (0, _pLimit.default)(concurrency || 100);
+  logger.info(`begin globbing '${pattern.glob}' with a context of '${pattern.context}'`);
+  return (0, _globby.default)(pattern.glob, globOptions).then(paths => Promise.all(paths.map(from => limit(() => {
+    const file = {
+      force: pattern.force,
+      absoluteFrom: _path.default.resolve(pattern.context, from)
+    };
+    file.relativeFrom = _path.default.relative(pattern.context, file.absoluteFrom);
+
+    if (pattern.flatten) {
+      file.relativeFrom = _path.default.basename(file.relativeFrom);
+    }
+
+    logger.debug(`found ${from}`); // Check the ignore list
+
+    let il = pattern.ignore.length; // eslint-disable-next-line no-plusplus
+
+    while (il--) {
+      const ignoreGlob = pattern.ignore[il];
+      let globParams = {
+        dot: true,
+        matchBase: true
+      };
+      let glob;
+
+      if (typeof ignoreGlob === 'string') {
+        glob = ignoreGlob;
+      } else if ((0, _isObject.default)(ignoreGlob)) {
+        glob = ignoreGlob.glob || '';
+        const ignoreGlobParams = Object.assign({}, ignoreGlob);
+        delete ignoreGlobParams.glob; // Overwrite minimatch defaults
+
+        globParams = Object.assign(globParams, ignoreGlobParams);
+      } else {
+        glob = '';
+      }
+
+      logger.debug(`testing ${glob} against ${file.relativeFrom}`);
+
+      if ((0, _minimatch.default)(file.relativeFrom, glob, globParams)) {
+        logger.info(`ignoring '${file.relativeFrom}', because it matches the ignore glob '${glob}'`);
+        return Promise.resolve();
+      }
+
+      logger.debug(`${glob} doesn't match ${file.relativeFrom}`);
+    } // Change the to path to be relative for webpack
+
+
+    if (pattern.toType === 'dir') {
+      file.webpackTo = _path.default.join(pattern.to, file.relativeFrom);
+    } else if (pattern.toType === 'file') {
+      file.webpackTo = pattern.to || file.relativeFrom;
+    } else if (pattern.toType === 'template') {
+      file.webpackTo = pattern.to;
+      file.webpackToRegExp = pattern.test;
+    }
+
+    if (_path.default.isAbsolute(file.webpackTo)) {
+      if (output === '/') {
+        const message = 'using older versions of webpack-dev-server, devServer.outputPath must be defined to write to absolute paths';
+        logger.error(message);
+        compilation.errors.push(new Error(message));
+      }
+
+      file.webpackTo = _path.default.relative(output, file.webpackTo);
+    }
+
+    logger.info(`determined that '${from}' should write to '${file.webpackTo}'`);
+    return file;
+  }))));
+}

node_modules/copy-webpack-plugin/dist/utils/isObject.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _default = val => Object.prototype.toString.call(val) === '[object Object]';
+
+exports.default = _default;

node_modules/copy-webpack-plugin/dist/utils/isTemplateLike.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _default = pattern => /(\[ext\])|(\[name\])|(\[path\])|(\[folder\])|(\[emoji(?::(\d+))?\])|(\[(?:([^:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*))?(?::(\d+))?\])|(\[\d+\])/.test(pattern);
+
+exports.default = _default;

node_modules/copy-webpack-plugin/dist/utils/normalize.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalize;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _normalizePath = _interopRequireDefault(require("normalize-path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function escape(context, from) {
+  if (from && _path.default.isAbsolute(from)) {
+    return from;
+  } // Ensure context is escaped before globbing
+  // Handles special characters in paths
+
+
+  const absoluteContext = _path.default.resolve(context) // Need refactor
+  // eslint-disable-next-line no-useless-escape
+  .replace(/[\*|\?|\!|\(|\)|\[|\]|\{|\}]/g, substring => `[${substring}]`);
+
+  if (!from) {
+    return absoluteContext;
+  } // Cannot use path.join/resolve as it "fixes" the path separators
+
+
+  if (absoluteContext.endsWith('/')) {
+    return `${absoluteContext}${from}`;
+  }
+
+  return `${absoluteContext}/${from}`;
+}
+
+function normalize(context, from) {
+  return (0, _normalizePath.default)(escape(context, from));
+}

node_modules/copy-webpack-plugin/dist/utils/promisify.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readFile = exports.stat = void 0;
+
+const stat = (inputFileSystem, path) => new Promise((resolve, reject) => {
+  inputFileSystem.stat(path, (err, stats) => {
+    if (err) {
+      reject(err);
+    }
+
+    resolve(stats);
+  });
+});
+
+exports.stat = stat;
+
+const readFile = (inputFileSystem, path) => new Promise((resolve, reject) => {
+  inputFileSystem.readFile(path, (err, stats) => {
+    if (err) {
+      reject(err);
+    }
+
+    resolve(stats);
+  });
+});
+
+exports.readFile = readFile;