fix: ignored file

jest.config.js

@@ -1,6 +1,6 @@
 module.exports = {
+  collectCoverageFrom: ['src/**/*.js'],
   collectCoverage: true,
   testEnvironment: 'node',
   testTimeout: 60000,
-  transformIgnorePatterns: ['node_modules/(?!(arrify)/)'],
 };

src/getStylelint.js

@@ -15,18 +15,20 @@ const cache = {};
 /** @typedef {import('./options').Options} Options */
 /** @typedef {() => Promise<void>} AsyncTask */
 /** @typedef {(files: string|string[]) => Promise<LintResult[]>} LintTask */
-/** @typedef {{stylelint: Stylelint, lintFiles: LintTask, cleanup: AsyncTask, threads: number, }} Linter */
+/** @typedef {{api: import('stylelint').InternalApi, stylelint: Stylelint, lintFiles: LintTask, cleanup: AsyncTask, threads: number, }} Linter */
 /** @typedef {import('jest-worker').Worker & {lintFiles: LintTask}} Worker */
 
 /**
  * @param {Options} options
  * @returns {Linter}
  */
 function loadStylelint(options) {
-  const stylelint = setup(options, getStylelintOptions(options));
+  const stylelintOptions = getStylelintOptions(options);
+  const stylelint = setup(options, stylelintOptions);
 
   return {
     stylelint,
+    api: stylelint.createLinter(stylelintOptions),
     lintFiles,
     cleanup: async () => {},
     threads: 1,

src/index.js

@@ -88,26 +88,46 @@ class StylelintWebpackPlugin {
     compiler.hooks.thisCompilation.tap(this.key, (compilation) => {
       /** @type {import('./linter').Linter} */
       let lint;
+
+      /** @type {import('stylelint').InternalApi} */
+      let api;
+
       /** @type {import('./linter').Reporter} */
       let report;
+
       /** @type number */
       let threads;
 
       try {
-        ({ lint, report, threads } = linter(this.key, options, compilation));
+        ({ lint, api, report, threads } = linter(
+          this.key,
+          options,
+          compilation
+        ));
       } catch (e) {
         compilation.errors.push(e);
         return;
       }
 
-      compilation.hooks.finishModules.tap(this.key, () => {
-        const files = compiler.modifiedFiles
-          ? Array.from(compiler.modifiedFiles).filter(
-              (file) =>
-                isMatch(file, wanted, { dot: true }) &&
-                !isMatch(file, exclude, { dot: true })
-            )
-          : globby.sync(wanted, { dot: true, ignore: exclude });
+      compilation.hooks.finishModules.tapPromise(this.key, async () => {
+        const files = (
+          await Promise.all(
+            (compiler.modifiedFiles
+              ? Array.from(compiler.modifiedFiles).filter(
+                  (file) =>
+                    isMatch(file, wanted, { dot: true }) &&
+                    !isMatch(file, exclude, { dot: true })
+                )
+              : globby.sync(wanted, { dot: true, ignore: exclude })
+            ).map(async (/** @type {string | undefined} */ file) => {
+              try {
+                return (await api.isPathIgnored(file)) ? false : file;
+              } catch (e) {
+                return file;
+              }
+            })
+          )
+        ).filter((file) => file !== false);
 
         if (threads > 1) {
           for (const file of files) {

src/linter.js

@@ -6,6 +6,7 @@ import { arrify } from './utils';
 
 /** @typedef {import('stylelint')} Stylelint */
 /** @typedef {import('stylelint').LintResult} LintResult */
+/** @typedef {import('stylelint').InternalApi} InternalApi */
 /** @typedef {import('webpack').Compiler} Compiler */
 /** @typedef {import('webpack').Compilation} Compilation */
 /** @typedef {import('./options').Options} Options */
@@ -24,12 +25,15 @@ const resultStorage = new WeakMap();
  * @param {string|undefined} key
  * @param {Options} options
  * @param {Compilation} compilation
- * @returns {{lint: Linter, report: Reporter, threads: number}}
+ * @returns {{api: InternalApi, lint: Linter, report: Reporter, threads: number}}
  */
 export default function linter(key, options, compilation) {
   /** @type {Stylelint} */
   let stylelint;
 
+  /** @type {InternalApi} */
+  let api;
+
   /** @type {(files: string|string[]) => Promise<LintResult[]>} */
   let lintFiles;
 
@@ -45,13 +49,17 @@ export default function linter(key, options, compilation) {
   const crossRunResultStorage = getResultStorage(compilation);
 
   try {
-    ({ stylelint, lintFiles, cleanup, threads } = getStylelint(key, options));
+    ({ stylelint, api, lintFiles, cleanup, threads } = getStylelint(
+      key,
+      options
+    ));
   } catch (e) {
     throw new StylelintError(e.message);
   }
 
   return {
     lint,
+    api,
     report,
     threads,
   };

test/fixtures/stylelintignore/.stylelintignore

@@ -0,0 +1,7 @@
+ignore.scss
+
+# comment
+
+noop.scss
+
+ignore.scss

test/fixtures/stylelintignore/ignore.scss

@@ -0,0 +1,3 @@
+#stuff {
+  display: "block"; // error
+}

test/fixtures/stylelintignore/index.js

@@ -0,0 +1,2 @@
+require('file-loader!./test.scss');
+require('file-loader!./ignore.scss');

test/fixtures/stylelintignore/test.scss

@@ -0,0 +1,3 @@
+body {
+  display: block;
+}

test/mock/stylelint/index.js

@@ -24,4 +24,12 @@ module.exports = {
       ],
     };
   },
+
+  createLinter() {
+    return {
+      isPathIgnored() {
+        return false;
+      },
+    };
+  },
 };

test/stylelint-ignore.test.js

@@ -0,0 +1,13 @@
+import pack from './utils/pack';
+
+describe('stylelint ignore', () => {
+  it('should ignore file', (done) => {
+    const compiler = pack('stylelintignore');
+
+    compiler.run((err, stats) => {
+      expect(stats.hasWarnings()).toBe(false);
+      expect(stats.hasErrors()).toBe(false);
+      done();
+    });
+  });
+});

test/stylelint-lint.test.js

@@ -9,6 +9,11 @@ describe('stylelint lint', () => {
     jest.mock('stylelint', () => {
       return {
         lint: mockLintFiles,
+        createLinter: () => {
+          return {
+            isPathIgnored: () => false,
+          };
+        },
       };
     });
   });