stylelint-webpack-plugin 2.1.1 → 2.3.0

package/dist/getStylelint.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getStylelint;
+
+var _os = require("os");
+
+var _jestWorker = require("jest-worker");
+
+var _worker = require("./worker");
+
+var _utils = require("./utils");
+
+var _options = require("./options");
+
+// @ts-ignore
+
+/** @type {{[key: string]: any}} */
+const cache = {};
+/** @typedef {import('stylelint')} Stylelint */
+
+/** @typedef {import('stylelint').LintResult} LintResult */
+
+/** @typedef {import('./options').Options} Options */
+
+/** @typedef {() => Promise<void>} AsyncTask */
+
+/** @typedef {(files: string|string[]) => Promise<LintResult[]>} LintTask */
+
+/** @typedef {JestWorker & {lintFiles: LintTask}} Worker */
+
+/** @typedef {{stylelint: Stylelint, lintFiles: LintTask, cleanup: AsyncTask, threads: number, }} Linter */
+
+/**
+ * @param {Options} options
+ * @returns {Linter}
+ */
+
+function loadStylelint(options) {
+  const stylelint = (0, _worker.setup)(options, (0, _options.getStylelintOptions)(options));
+  return {
+    stylelint,
+    lintFiles: _worker.lintFiles,
+    cleanup: async () => {},
+    threads: 1
+  };
+}
+/**
+ * @param {string|undefined} key
+ * @param {number} poolSize
+ * @param {Options} options
+ * @returns {Linter}
+ */
+
+
+function loadStylelintThreaded(key, poolSize, options) {
+  const cacheKey = getCacheKey(key, options);
+
+  const source = require.resolve('./worker');
+
+  const workerOptions = {
+    enableWorkerThreads: true,
+    numWorkers: poolSize,
+    setupArgs: [options, (0, _options.getStylelintOptions)(options)]
+  };
+  const local = loadStylelint(options);
+  /** @type {Worker?} */
+  // prettier-ignore
+
+  let worker =
+  /** @type {Worker} */
+  new _jestWorker.Worker(source, workerOptions);
+  /** @type {Linter} */
+
+  const context = { ...local,
+    threads: poolSize,
+    lintFiles: async files =>
+    /* istanbul ignore next */
+    worker ? worker.lintFiles(files) : local.lintFiles(files),
+    cleanup: async () => {
+      cache[cacheKey] = local;
+
+      context.lintFiles = files => local.lintFiles(files);
+      /* istanbul ignore next */
+
+
+      if (worker) {
+        worker.end();
+        worker = null;
+      }
+    }
+  };
+  return context;
+}
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @returns {Linter}
+ */
+
+
+function getStylelint(key, {
+  threads,
+  ...options
+}) {
+  const max = typeof threads !== 'number' ? threads ? (0, _os.cpus)().length - 1 : 1 : threads;
+  const cacheKey = getCacheKey(key, {
+    threads,
+    ...options
+  });
+
+  if (!cache[cacheKey]) {
+    cache[cacheKey] = max > 1 ? loadStylelintThreaded(key, max, options) : loadStylelint(options);
+  }
+
+  return cache[cacheKey];
+}
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @returns {string}
+ */
+
+
+function getCacheKey(key, options) {
+  return JSON.stringify({
+    key,
+    options
+  }, _utils.jsonStringifyReplacerSortKeys);
+}

package/dist/index.js

@@ -7,9 +7,13 @@ exports.default = void 0;
 
 var _path = require("path");
 
-var _getOptions = _interopRequireDefault(require("./getOptions"));
+var _arrify = _interopRequireDefault(require("arrify"));
 
-var _LintDirtyModulesPlugin = _interopRequireDefault(require("./LintDirtyModulesPlugin"));
+var _globby = _interopRequireDefault(require("globby"));
+
+var _micromatch = require("micromatch");
+
+var _options = require("./options");
 
 var _linter = _interopRequireDefault(require("./linter"));
 
@@ -17,10 +21,31 @@ var _utils = require("./utils");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+// @ts-ignore
+// @ts-ignore
+
 /** @typedef {import('webpack').Compiler} Compiler */
+
+/** @typedef {import('webpack').Module} Module */
+
+/** @typedef {import('./options').Options} Options */
+
+/** @typedef {Partial<{timestamp:number} | number>} FileSystemInfoEntry */
+const STYLELINT_PLUGIN = 'StylelintWebpackPlugin';
+let counter = 0;
+
 class StylelintWebpackPlugin {
+  /**
+   * @param {Options} options
+   */
   constructor(options = {}) {
-    this.options = (0, _getOptions.default)(options);
+    this.key = STYLELINT_PLUGIN;
+    this.options = (0, _options.getOptions)(options);
+    this.run = this.run.bind(this);
+    this.startTime = Date.now();
+    /** @type {ReadonlyMap<string, null | FileSystemInfoEntry | "ignore" | undefined>} */
+
+    this.prevTimestamps = new Map();
   }
   /**
    * @param {Compiler} compiler
@@ -29,35 +54,112 @@ class StylelintWebpackPlugin {
 
 
   apply(compiler) {
-    const options = { ...this.options,
-      files: (0, _utils.parseFiles)(this.options.files, this.getContext(compiler))
-    }; // eslint-disable-next-line
-
-    const {
-      lint
-    } = require(options.stylelintPath);
-
-    const {
-      name: plugin
-    } = this.constructor;
-
-    if (options.lintDirtyModulesOnly) {
-      const lintDirty = new _LintDirtyModulesPlugin.default(lint, compiler, options);
-      /* istanbul ignore next */
-
-      compiler.hooks.watchRun.tapAsync(plugin, (compilation, callback) => {
-        lintDirty.apply(compilation, callback);
-      });
-    } else {
-      compiler.hooks.run.tapAsync(plugin, (compilation, callback) => {
-        (0, _linter.default)(lint, options, compilation, callback);
-      });
-      /* istanbul ignore next */
-
-      compiler.hooks.watchRun.tapAsync(plugin, (compilation, callback) => {
-        (0, _linter.default)(lint, options, compilation, callback);
-      });
+    // Generate key for each compilation,
+    // this differentiates one from the other when being cached.
+    this.key = compiler.name || `${this.key}_${counter += 1}`; // If `lintDirtyModulesOnly` is disabled,
+    // execute the linter on the build
+
+    if (!this.options.lintDirtyModulesOnly) {
+      compiler.hooks.run.tapPromise(this.key, this.run);
     }
+
+    let isFirstRun = this.options.lintDirtyModulesOnly;
+    compiler.hooks.watchRun.tapPromise(this.key, c => {
+      if (isFirstRun) {
+        isFirstRun = false;
+        return Promise.resolve();
+      }
+
+      return this.run(c);
+    });
+  }
+  /**
+   * @param {Compiler} compiler
+   */
+
+
+  async run(compiler) {
+    // Do not re-hook
+
+    /* istanbul ignore if */
+    if ( // @ts-ignore
+    compiler.hooks.thisCompilation.taps.find(({
+      name
+    }) => name === this.key)) {
+      return;
+    }
+
+    const context = this.getContext(compiler);
+    const options = { ...this.options,
+      exclude: (0, _utils.parseFiles)(this.options.exclude || ['**/node_modules/**', compiler.options.output.path], context),
+      extensions: (0, _arrify.default)(this.options.extensions),
+      files: (0, _utils.parseFiles)(this.options.files || '', context)
+    };
+    const wanted = (0, _utils.parseFoldersToGlobs)(options.files, options.extensions);
+    const exclude = (0, _utils.parseFoldersToGlobs)(options.exclude);
+    compiler.hooks.thisCompilation.tap(this.key, compilation => {
+      /** @type {import('./linter').Linter} */
+      let lint;
+      /** @type {import('./linter').Reporter} */
+
+      let report;
+      /** @type number */
+
+      let threads;
+
+      try {
+        ({
+          lint,
+          report,
+          threads
+        } = (0, _linter.default)(this.key, options, compilation));
+      } catch (e) {
+        compilation.errors.push(e);
+        return;
+      }
+
+      compilation.hooks.finishModules.tap(this.key, () => {
+        const files = this.getFiles(compiler, wanted, exclude);
+
+        if (threads > 1) {
+          for (const file of files) {
+            lint((0, _utils.parseFiles)(file, context));
+          }
+        } else if (files.length > 0) {
+          lint((0, _utils.parseFiles)(files, context));
+        }
+      }); // await and interpret results
+
+      compilation.hooks.additionalAssets.tapPromise(this.key, processResults);
+
+      async function processResults() {
+        const {
+          errors,
+          warnings,
+          generateReportAsset
+        } = await report();
+
+        if (warnings && !options.failOnWarning) {
+          // @ts-ignore
+          compilation.warnings.push(warnings);
+        } else if (warnings && options.failOnWarning) {
+          // @ts-ignore
+          compilation.errors.push(warnings);
+        }
+
+        if (errors && options.failOnError) {
+          // @ts-ignore
+          compilation.errors.push(errors);
+        } else if (errors && !options.failOnError) {
+          // @ts-ignore
+          compilation.warnings.push(errors);
+        }
+
+        if (generateReportAsset) {
+          await generateReportAsset(compilation);
+        }
+      }
+    });
   }
   /**
    *
@@ -77,6 +179,88 @@ class StylelintWebpackPlugin {
 
     return this.options.context;
   }
+  /**
+   * @param {Compiler} compiler
+   * @param {string[]} wanted
+   * @param {string[]} exclude
+   * @returns {string[]}
+   */
+  // eslint-disable-next-line no-unused-vars
+
+
+  getFiles(compiler, wanted, exclude) {
+    // webpack 5
+    if (compiler.modifiedFiles) {
+      return Array.from(compiler.modifiedFiles).filter(file => (0, _micromatch.isMatch)(file, wanted, {
+        dot: true
+      }) && !(0, _micromatch.isMatch)(file, exclude, {
+        dot: true
+      }));
+    } // webpack 4
+
+    /* istanbul ignore next */
+
+
+    if (compiler.fileTimestamps && compiler.fileTimestamps.size > 0) {
+      return this.getChangedFiles(compiler.fileTimestamps).filter(file => (0, _micromatch.isMatch)(file, wanted, {
+        dot: true
+      }) && !(0, _micromatch.isMatch)(file, exclude, {
+        dot: true
+      }));
+    }
+
+    return _globby.default.sync(wanted, {
+      dot: true,
+      ignore: exclude
+    });
+  }
+  /**
+   * @param {ReadonlyMap<string, null | FileSystemInfoEntry | "ignore" | undefined>} fileTimestamps
+   * @returns {string[]}
+   */
+
+  /* istanbul ignore next */
+
+
+  getChangedFiles(fileTimestamps) {
+    /**
+     * @param {null | FileSystemInfoEntry | "ignore" | undefined} fileSystemInfoEntry
+     * @returns {Partial<number>}
+     */
+    const getTimestamps = fileSystemInfoEntry => {
+      // @ts-ignore
+      if (fileSystemInfoEntry && fileSystemInfoEntry.timestamp) {
+        // @ts-ignore
+        return fileSystemInfoEntry.timestamp;
+      } // @ts-ignore
+
+
+      return fileSystemInfoEntry;
+    };
+    /**
+     * @param {string} filename
+     * @param {null | FileSystemInfoEntry | "ignore" | undefined} fileSystemInfoEntry
+     * @returns {boolean}
+     */
+
+
+    const hasFileChanged = (filename, fileSystemInfoEntry) => {
+      const prevTimestamp = getTimestamps(this.prevTimestamps.get(filename));
+      const timestamp = getTimestamps(fileSystemInfoEntry);
+      return (prevTimestamp || this.startTime) < (timestamp || Infinity);
+    };
+
+    const changedFiles = [];
+
+    for (const [filename, timestamp] of fileTimestamps.entries()) {
+      if (hasFileChanged(filename, timestamp)) {
+        changedFiles.push(filename);
+      }
+    }
+
+    this.prevTimestamps = fileTimestamps;
+    return changedFiles;
+  }
 
 }