refactor: revert picomatch back to minimatch (#256)

Author: JounQin

.changeset/red-pumpkins-tease.md

@@ -0,0 +1,5 @@
+---
+"eslint-plugin-import-x": patch
+---
+
+refactor: revert `picomatch` back to `minimatch`

.github/workflows/pkg-pr-new.yml

@@ -27,4 +27,4 @@ jobs:
       - name: Build
         run: yarn build
 
-      - run: yarn dlx pkg-pr-new publish
+      - run: yarn dlx pkg-pr-new publish --compact

package.json

@@ -3,7 +3,7 @@
   "version": "4.9.0",
   "type": "commonjs",
   "description": "Import with sanity.",
-  "repository": "git+https://github.com/un-ts/eslint-plugin-import-x",
+  "repository": "https://github.com/un-ts/eslint-plugin-import-x",
   "author": "JounQin <admin@1stg.me> (https://www.1stG.me)",
   "license": "MIT",
   "packageManager": "yarn@4.7.0",
@@ -49,13 +49,14 @@
   },
   "dependencies": {
     "@types/doctrine": "^0.0.9",
-    "@typescript-eslint/utils": "^8.26.1",
+    "@typescript-eslint/utils": "^8.27.0",
     "debug": "^4.4.0",
     "doctrine": "^3.0.0",
     "eslint-import-resolver-node": "^0.3.9",
     "get-tsconfig": "^4.10.0",
-    "picomatch": "^4.0.2",
-    "rspack-resolver": "^1.2.1",
+    "is-glob": "^4.0.3",
+    "minimatch": "^10.0.1",
+    "rspack-resolver": "^1.2.2",
     "semver": "^7.7.1",
     "stable-hash": "^0.0.5",
     "tslib": "^2.8.1"
@@ -89,22 +90,22 @@
     "@types/debug": "^4.1.12",
     "@types/eslint": "^9.6.1",
     "@types/eslint8.56": "npm:@types/eslint@~8.56.0",
+    "@types/is-glob": "^4.0.4",
     "@types/jest": "^29.5.14",
     "@types/json-schema": "^7.0.15",
     "@types/klaw-sync": "^6.0.5",
     "@types/node": "^20.17.24",
-    "@types/picomatch": "^3.0.2",
     "@types/pnpapi": "^0.0.5",
-    "@typescript-eslint/eslint-plugin": "^8.26.1",
-    "@typescript-eslint/parser": "^8.26.1",
-    "@typescript-eslint/rule-tester": "^8.26.1",
+    "@typescript-eslint/eslint-plugin": "^8.27.0",
+    "@typescript-eslint/parser": "^8.27.0",
+    "@typescript-eslint/rule-tester": "^8.27.0",
     "@unts/patch-package": "^8.1.1",
     "clean-pkg-json": "^1.2.1",
     "cross-env": "^7.0.3",
     "eslint": "^9.22.0",
     "eslint-config-prettier": "^10.1.1",
     "eslint-doc-generator": "^2.1.2",
-    "eslint-import-resolver-typescript": "^4.2.1",
+    "eslint-import-resolver-typescript": "^4.2.2",
     "eslint-import-resolver-webpack": "^0.13.10",
     "eslint-import-test-order-redirect": "link:./test/fixtures/order-redirect",
     "eslint-plugin-eslint-plugin": "^6.4.0",
@@ -120,7 +121,7 @@
     "eslint9": "npm:eslint@^9.22.0",
     "hermes-eslint": "^0.26.0",
     "jest": "^29.7.0",
-    "klaw-sync": "^6.0.0",
+    "klaw-sync": "^7.0.0",
     "lint-staged": "^15.5.0",
     "npm-run-all2": "^7.0.2",
     "path-serializer": "^0.3.4",

src/rules/no-extraneous-dependencies.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 
 import type { TSESTree } from '@typescript-eslint/utils'
+import { minimatch } from 'minimatch'
 import type { PackageJson } from 'type-fest'
 
 import type { RuleContext } from '../types'
@@ -12,7 +13,6 @@ import {
   pkgUp,
   importType,
   getFilePackageName,
-  isFileMatch,
 } from '../utils'
 
 type PackageDeps = ReturnType<typeof extractDepFields>
@@ -329,11 +329,16 @@ function reportIfMissing(
 }
 
 function testConfig(config: string[] | boolean | undefined, filename: string) {
-  return Array.isArray(config)
-    ? // Array of globs.
-      isFileMatch(filename, config)
-    : // Simplest configuration first, either a boolean or nothing.
-      config
+  // Simplest configuration first, either a boolean or nothing.
+  if (typeof config === 'boolean' || config === undefined) {
+    return config
+  }
+  // Array of globs.
+  return config.some(
+    c =>
+      minimatch(filename, c) ||
+      minimatch(filename, path.resolve(c), { windowsPathsNoEscape: true }),
+  )
 }
 
 type Options = {

src/rules/no-import-module-exports.ts

@@ -1,9 +1,10 @@
 import path from 'node:path'
 
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils'
+import { minimatch } from 'minimatch'
 
 import type { RuleContext } from '../types'
-import { createRule, matcher, pkgUp } from '../utils'
+import { createRule, pkgUp } from '../utils'
 
 function getEntryPoint(context: RuleContext) {
   const pkgPath = pkgUp({
@@ -78,8 +79,6 @@ export = createRule<[Options?], MessageId>({
 
     let alreadyReported = false
 
-    const isMatch = matcher(options.exceptions)
-
     return {
       ImportDeclaration(node) {
         importDeclarations.push(node)
@@ -112,7 +111,7 @@ export = createRule<[Options?], MessageId>({
           isIdentifier &&
           hasCJSExportReference &&
           !isEntryPoint &&
-          !isMatch(filename) &&
+          !options.exceptions?.some(glob => minimatch(filename, glob)) &&
           !isImportBinding
         ) {
           for (const importDeclaration of importDeclarations) {

src/rules/no-internal-modules.ts

@@ -1,12 +1,8 @@
-import {
-  importType,
-  createRule,
-  moduleVisitor,
-  resolve,
-  matcher,
-} from '../utils'
-
-// picomatch patterns are expected to use / path separators, like import
+import { makeRe } from 'minimatch'
+
+import { importType, createRule, moduleVisitor, resolve } from '../utils'
+
+// minimatch patterns are expected to use / path separators, like import
 // statements, so normalize paths to use the same
 function normalizeSep(somePath: string) {
   return somePath.split('\\').join('/')
@@ -84,21 +80,21 @@ export = createRule<[Options?], MessageId>({
   defaultOptions: [],
   create(context) {
     const options = context.options[0] || {}
-    const allowMatches = (options.allow || [])
-      .map(p => matcher(p))
+    const allowRegexps = (options.allow || [])
+      .map(p => makeRe(p))
       .filter(Boolean)
-    const forbidMatches = (options.forbid || [])
-      .map(p => matcher(p))
+    const forbidRegexps = (options.forbid || [])
+      .map(p => makeRe(p))
       .filter(Boolean)
 
     // test if reaching to this destination is allowed
     function reachingAllowed(importPath: string) {
-      return allowMatches.some(m => m(importPath))
+      return allowRegexps.some(re => re.test(importPath))
     }
 
     // test if reaching to this destination is forbidden
     function reachingForbidden(importPath: string) {
-      return forbidMatches.some(m => m(importPath))
+      return forbidRegexps.some(re => re.test(importPath))
     }
 
     function isAllowViolation(importPath: string) {

src/rules/no-namespace.ts

@@ -3,8 +3,9 @@
  */
 
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils'
+import { minimatch } from 'minimatch'
 
-import { createRule, matcher } from '../utils'
+import { createRule } from '../utils'
 
 type MessageId = 'noNamespace'
 
@@ -44,11 +45,13 @@ export = createRule<[Options?], MessageId>({
     const firstOption = context.options[0] || {}
     const ignoreGlobs = firstOption.ignore
 
-    const isMatch = matcher(ignoreGlobs, { matchBase: true })
-
     return {
       ImportNamespaceSpecifier(node) {
-        if (isMatch(node.parent.source.value)) {
+        if (
+          ignoreGlobs?.find(glob =>
+            minimatch(node.parent.source.value, glob, { matchBase: true }),
+          )
+        ) {
           return
         }
 

src/rules/no-restricted-paths.ts

@@ -1,26 +1,21 @@
 import path from 'node:path'
 
 import type { TSESTree } from '@typescript-eslint/utils'
+import isGlob from 'is-glob'
+import { Minimatch } from 'minimatch'
 
 import type { Arrayable } from '../types'
-import {
-  importType,
-  createRule,
-  moduleVisitor,
-  resolve,
-  isDynamicPattern,
-  fileMatcher,
-  isMatch,
-} from '../utils'
+import { importType, createRule, moduleVisitor, resolve } from '../utils'
 
 const containsPath = (filepath: string, target: string) => {
   const relative = path.relative(target, filepath)
   return relative === '' || !relative.startsWith('..')
 }
 
 function isMatchingTargetPath(filename: string, targetPath: string) {
-  if (isDynamicPattern(targetPath)) {
-    return isMatch(filename, targetPath)
+  if (isGlob(targetPath)) {
+    const mm = new Minimatch(targetPath, { windowsPathsNoEscape: true })
+    return mm.match(filename)
   }
 
   return containsPath(filename, targetPath)
@@ -176,13 +171,17 @@ export = createRule<[Options?], MessageId>({
     ) {
       let isPathException: ((absoluteImportPath: string) => boolean) | undefined
 
-      const isPathRestricted = fileMatcher(absoluteFrom)
-      const hasValidExceptions = zoneExcept.every(it => isDynamicPattern(it))
+      const mm = new Minimatch(absoluteFrom, { windowsPathsNoEscape: true })
+      const isPathRestricted = (absoluteImportPath: string) =>
+        mm.match(absoluteImportPath)
+      const hasValidExceptions = zoneExcept.every(it => isGlob(it))
 
       if (hasValidExceptions) {
-        const exceptionsMm = zoneExcept.map(except => fileMatcher(except))
+        const exceptionsMm = zoneExcept.map(
+          except => new Minimatch(except, { windowsPathsNoEscape: true }),
+        )
         isPathException = (absoluteImportPath: string) =>
-          exceptionsMm.some(mm => mm(absoluteImportPath))
+          exceptionsMm.some(mm => mm.match(absoluteImportPath))
       }
 
       const reportInvalidException = reportInvalidExceptionGlob
@@ -259,7 +258,7 @@ export = createRule<[Options?], MessageId>({
       zoneExcept: string[] = [],
     ) => {
       const allZoneFrom = [zoneFrom].flat()
-      const areGlobPatterns = allZoneFrom.map(it => isDynamicPattern(it))
+      const areGlobPatterns = allZoneFrom.map(it => isGlob(it))
 
       if (areBothGlobPatternAndAbsolutePath(areGlobPatterns)) {
         return [computeMixedGlobAndAbsolutePathValidator()]

src/rules/no-unassigned-import.ts

@@ -1,6 +1,8 @@
 import path from 'node:path'
 
-import { isStaticRequire, createRule, isFileMatch } from '../utils'
+import { minimatch } from 'minimatch'
+
+import { isStaticRequire, createRule } from '../utils'
 
 function testIsAllow(
   globs: string[] | undefined,
@@ -17,7 +19,11 @@ function testIsAllow(
       ? source
       : path.resolve(filename, '..', source) // get source absolute path
 
-  return isFileMatch(filePath, globs)
+  return globs.some(
+    glob =>
+      minimatch(filePath, glob) ||
+      minimatch(filePath, path.resolve(glob), { windowsPathsNoEscape: true }),
+  )
 }
 
 type Options = {

src/rules/order.ts

@@ -1,5 +1,6 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils'
 import debug from 'debug'
+import { minimatch } from 'minimatch'
 
 import type {
   AlphabetizeOptions,
@@ -16,13 +17,7 @@ import type {
   RanksPathGroup,
   RuleContext,
 } from '../types'
-import {
-  createRule,
-  getValue,
-  importType,
-  isMatch,
-  isStaticRequire,
-} from '../utils'
+import { getValue, importType, isStaticRequire, createRule } from '../utils'
 
 const log = debug('eslint-plugin-import-x:rules:order')
 
@@ -706,7 +701,7 @@ function computePathRank(
   maxPosition: number,
 ) {
   for (const { pattern, patternOptions, group, position = 1 } of pathGroups) {
-    if (isMatch(path, pattern, patternOptions)) {
+    if (minimatch(path, pattern, patternOptions || { nocomment: true })) {
       return ranks[group] + position / maxPosition
     }
   }