fix: path ignored (#312)

* fix: path ignored

* style: formatting

* chore: update cspell

* style: formatting

.cspell.json

@@ -19,8 +19,10 @@
   "ignorePaths": [
     "CHANGELOG.md",
     "package.json",
+    "coverage/**",
     "dist/**",
     "**/__snapshots__/**",
-    "package-lock.json"
+    "package-lock.json",
+    "/test/output"
   ]
 }

.github/workflows/dependency-review.yml

@@ -1,4 +1,4 @@
-name: "Dependency Review"
+name: 'Dependency Review'
 on: [pull_request]
 
 permissions:
@@ -8,7 +8,7 @@ jobs:
   dependency-review:
     runs-on: ubuntu-latest
     steps:
-      - name: "Checkout Repository"
+      - name: 'Checkout Repository'
         uses: actions/checkout@v3
-      - name: "Dependency Review"
+      - name: 'Dependency Review'
         uses: actions/dependency-review-action@v3

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/stylelint-path/ignore.scss

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

test/fixtures/stylelint-path/index.js

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

test/fixtures/stylelint-path/test.scss

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

test/mock/stylelint/index.js

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

test/mock/stylelint/lib/isPathIgnored.js

@@ -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/stylelint-ignore.test.js

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

test/stylelint-lint.test.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/stylelint-path.test.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();

types/getStylelint.d.ts

@@ -14,6 +14,7 @@ declare namespace getStylelint {
     Stylelint,
     LintResult,
     Options,
+    isPathIgnored,
     AsyncTask,
     LintTask,
     Linter,
@@ -22,8 +23,8 @@ declare namespace getStylelint {
 }
 type Options = import('./options').Options;
 type Linter = {
-  api: import('stylelint').InternalApi;
   stylelint: Stylelint;
+  isPathIgnored: isPathIgnored;
   lintFiles: LintTask;
   cleanup: AsyncTask;
   threads: number;
@@ -87,6 +88,10 @@ type Stylelint = import('postcss').PluginCreator<
   };
 };
 type LintResult = import('stylelint').LintResult;
+type isPathIgnored = (
+  stylelint: Stylelint,
+  filePath: string
+) => Promise<boolean>;
 type AsyncTask = () => Promise<void>;
 type LintTask = (files: string | string[]) => Promise<LintResult[]>;
 type Worker = JestWorker & {

types/linter.d.ts

@@ -4,14 +4,15 @@ export = linter;
  * @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}}
  */
 declare function linter(
   key: string | undefined,
   options: Options,
   compilation: Compilation
 ): {
-  api: InternalApi;
+  stylelint: Stylelint;
+  isPathIgnored: getStylelint.isPathIgnored;
   lint: Linter;
   report: Reporter;
   threads: number;
@@ -21,12 +22,12 @@ declare namespace linter {
     Stylelint,
     LintResult,
     LinterResult,
-    InternalApi,
     Formatter,
     FormatterType,
     Compiler,
     Compilation,
     Options,
+    isPathIgnored,
     GenerateReport,
     Report,
     Reporter,
@@ -36,9 +37,6 @@ declare namespace linter {
 }
 type Options = import('./options').Options;
 type Compilation = import('webpack').Compilation;
-type InternalApi = import('stylelint').InternalApi;
-type Linter = (files: string | string[]) => void;
-type Reporter = () => Promise<Report>;
 type Stylelint = import('postcss').PluginCreator<
   import('stylelint').PostcssPluginOptions
 > & {
@@ -97,11 +95,15 @@ type Stylelint = import('postcss').PluginCreator<
     longhandSubPropertiesOfShorthandProperties: import('stylelint').LonghandSubPropertiesOfShorthandProperties;
   };
 };
+type Linter = (files: string | string[]) => void;
+type Reporter = () => Promise<Report>;
+import getStylelint = require('./getStylelint');
 type LintResult = import('stylelint').LintResult;
 type LinterResult = import('stylelint').LinterResult;
 type Formatter = import('stylelint').Formatter;
 type FormatterType = import('stylelint').FormatterType;
 type Compiler = import('webpack').Compiler;
+type isPathIgnored = import('./getStylelint').isPathIgnored;
 type GenerateReport = (compilation: Compilation) => Promise<void>;
 type Report = {
   errors?: StylelintError;