fix: path ignored

Author: ricardogobbosouza

src/getStylelint.js

@@ -13,9 +13,10 @@ const cache = {};
 /** @typedef {import('stylelint')} Stylelint */
 /** @typedef {import('stylelint').LintResult} LintResult */
 /** @typedef {import('./options').Options} Options */
+/** @typedef {(stylelint: Stylelint, filePath: string) => Promise<boolean>} isPathIgnored */
 /** @typedef {() => Promise<void>} AsyncTask */
 /** @typedef {(files: string|string[]) => Promise<LintResult[]>} LintTask */
-/** @typedef {{api: import('stylelint').InternalApi, stylelint: Stylelint, lintFiles: LintTask, cleanup: AsyncTask, threads: number, }} Linter */
+/** @typedef {{stylelint: Stylelint, isPathIgnored: isPathIgnored, lintFiles: LintTask, cleanup: AsyncTask, threads: number }} Linter */
 /** @typedef {JestWorker & {lintFiles: LintTask}} Worker */
 
 /**
@@ -26,9 +27,23 @@ function loadStylelint(options) {
   const stylelintOptions = getStylelintOptions(options);
   const stylelint = setup(options, stylelintOptions);
 
+  /** @type {isPathIgnored} */
+  let isPathIgnored;
+
+  try {
+    isPathIgnored = require(`${options.stylelintPath}/lib/isPathIgnored`);
+  } catch (e) {
+    try {
+      // @ts-ignore
+      isPathIgnored = require('stylelint/lib/isPathIgnored');
+    } catch (_) {
+      isPathIgnored = () => Promise.resolve(false);
+    }
+  }
+
   return {
     stylelint,
-    api: stylelint.createLinter(stylelintOptions),
+    isPathIgnored,
     lintFiles,
     cleanup: async () => {},
     threads: 1,

src/index.js

@@ -90,11 +90,14 @@ class StylelintWebpackPlugin {
     }
 
     compiler.hooks.thisCompilation.tap(this.key, (compilation) => {
+      /** @type {import('stylelint')} */
+      let stylelint;
+
       /** @type {import('./linter').Linter} */
       let lint;
 
-      /** @type {import('stylelint').InternalApi} */
-      let api;
+      /** @type {import('./linter').isPathIgnored} */
+      let isPathIgnored;
 
       /** @type {import('./linter').Reporter} */
       let report;
@@ -103,7 +106,7 @@ class StylelintWebpackPlugin {
       let threads;
 
       try {
-        ({ lint, api, report, threads } = linter(
+        ({ stylelint, lint, isPathIgnored, report, threads } = linter(
           this.key,
           options,
           compilation
@@ -127,7 +130,7 @@ class StylelintWebpackPlugin {
               : globby.sync(wanted, { dot: true, ignore: exclude })
             ).map(async (file) => {
               try {
-                return (await api.isPathIgnored(file)) ? false : file;
+                return (await isPathIgnored(stylelint, file)) ? false : file;
               } catch (e) {
                 return file;
               }

src/linter.js

@@ -7,12 +7,12 @@ const { arrify } = require('./utils');
 /** @typedef {import('stylelint')} Stylelint */
 /** @typedef {import('stylelint').LintResult} LintResult */
 /** @typedef {import('stylelint').LinterResult} LinterResult */
-/** @typedef {import('stylelint').InternalApi} InternalApi */
 /** @typedef {import('stylelint').Formatter} Formatter */
 /** @typedef {import('stylelint').FormatterType} FormatterType */
 /** @typedef {import('webpack').Compiler} Compiler */
 /** @typedef {import('webpack').Compilation} Compilation */
 /** @typedef {import('./options').Options} Options */
+/** @typedef {import('./getStylelint').isPathIgnored} isPathIgnored */
 /** @typedef {(compilation: Compilation) => Promise<void>} GenerateReport */
 /** @typedef {{errors?: StylelintError, warnings?: StylelintError, generateReportAsset?: GenerateReport}} Report */
 /** @typedef {() => Promise<Report>} Reporter */
@@ -26,14 +26,14 @@ const resultStorage = new WeakMap();
  * @param {string|undefined} key
  * @param {Options} options
  * @param {Compilation} compilation
- * @returns {{api: InternalApi, lint: Linter, report: Reporter, threads: number}}
+ * @returns {{stylelint: Stylelint, isPathIgnored: isPathIgnored, lint: Linter, report: Reporter, threads: number}}
  */
 function linter(key, options, compilation) {
   /** @type {Stylelint} */
   let stylelint;
 
-  /** @type {InternalApi} */
-  let api;
+  /** @type {isPathIgnored} */
+  let isPathIgnored;
 
   /** @type {(files: string|string[]) => Promise<LintResult[]>} */
   let lintFiles;
@@ -50,7 +50,7 @@ function linter(key, options, compilation) {
   const crossRunResultStorage = getResultStorage(compilation);
 
   try {
-    ({ stylelint, api, lintFiles, cleanup, threads } = getStylelint(
+    ({ stylelint, isPathIgnored, lintFiles, cleanup, threads } = getStylelint(
       key,
       options
     ));
@@ -59,8 +59,9 @@ function linter(key, options, compilation) {
   }
 
   return {
+    stylelint,
     lint,
-    api,
+    isPathIgnored,
     report,
     threads,
   };

test/fixtures/stylelintignore/test.scss renamed to test/fixtures/stylelint-path/ignore.scss

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

test/fixtures/stylelintignore/index.js renamed to test/fixtures/stylelint-path/index.js

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

test/fixtures/stylelint-path/test.scss

@@ -0,0 +1,12 @@
+/**
+ * @param {import('stylelint')} stylelint
+ * @param {string} filePath
+ * @returns {Promise<boolean>}
+ */
+function isPathIgnored(stylelint, filePath) {
+  return new Promise((resolve) => {
+    resolve(filePath.endsWith('ignore.scss'));
+  });
+}
+
+module.exports = isPathIgnored;

test/mock/stylelint/index.js

@@ -9,13 +9,12 @@ describe('stylelint lint', () => {
     jest.mock('stylelint', () => {
       return {
         lint: mockLintFiles,
-        createLinter: () => {
-          return {
-            isPathIgnored: () => false,
-          };
-        },
       };
     });
+
+    jest.mock('stylelint/lib/isPathIgnored', () => {
+      throw new Error();
+    });
   });
 
   beforeEach(() => {

test/mock/stylelint/lib/isPathIgnored.js

@@ -5,7 +5,7 @@ import pack from './utils/pack';
 describe('stylelint path', () => {
   it('should use another instance of stylelint via stylelintPath config', (done) => {
     const stylelintPath = join(__dirname, 'mock/stylelint');
-    const compiler = pack('good', { stylelintPath });
+    const compiler = pack('stylelint-path', { stylelintPath });
 
     compiler.run((err, stats) => {
       expect(err).toBeNull();