Refactor utils (#710)

Author: RunDevelopment

docs/.vitepress/config.mts

@@ -3,7 +3,7 @@ import { defineConfig } from "vitepress"
 import { BUNDLED_LANGUAGES } from "shiki"
 import path from "path"
 import { fileURLToPath } from "url"
-import { rules } from "../../lib/utils/rules.js"
+import { rules } from "../../lib/all-rules.js"
 import type { RuleModule } from "../../lib/types.js"
 
 // Pre-build cjs packages that cannot be bundled well.

docs/.vitepress/theme/components/components/EslintPluginEditor.vue

@@ -18,7 +18,7 @@
 <script>
 import EslintEditor from "@ota-meshi/site-kit-eslint-editor-vue"
 import { Linter } from "eslint"
-import { rules } from "../../../../../lib/utils/rules"
+import { rules } from "../../../../../lib/all-rules"
 
 export default {
     name: "EslintPluginEditor",

docs/.vitepress/theme/components/rules/index.js

@@ -1,5 +1,5 @@
 import { Linter } from "eslint"
-import { rules } from "../../../../../lib/utils/rules.ts"
+import { rules } from "../../../../../lib/all-rules.ts"
 import { rules as recommendedRules } from "../../../../../lib/configs/recommended.ts"
 
 const coreRules = Object.fromEntries(new Linter().getRules())

lib/all-rules.ts

@@ -0,0 +1,166 @@
+import type { RuleModule } from "./types"
+import confusingQuantifier from "./rules/confusing-quantifier"
+import controlCharacterEscape from "./rules/control-character-escape"
+import graphemeStringLiteral from "./rules/grapheme-string-literal"
+import hexadecimalEscape from "./rules/hexadecimal-escape"
+import letterCase from "./rules/letter-case"
+import matchAny from "./rules/match-any"
+import negation from "./rules/negation"
+import noContradictionWithAssertion from "./rules/no-contradiction-with-assertion"
+import noControlCharacter from "./rules/no-control-character"
+import noDupeCharactersCharacterClass from "./rules/no-dupe-characters-character-class"
+import noDupeDisjunctions from "./rules/no-dupe-disjunctions"
+import noEmptyAlternative from "./rules/no-empty-alternative"
+import noEmptyCapturingGroup from "./rules/no-empty-capturing-group"
+import noEmptyCharacterClass from "./rules/no-empty-character-class"
+import noEmptyGroup from "./rules/no-empty-group"
+import noEmptyLookaroundsAssertion from "./rules/no-empty-lookarounds-assertion"
+import noEmptyStringLiteral from "./rules/no-empty-string-literal"
+import noEscapeBackspace from "./rules/no-escape-backspace"
+import noExtraLookaroundAssertions from "./rules/no-extra-lookaround-assertions"
+import noInvalidRegexp from "./rules/no-invalid-regexp"
+import noInvisibleCharacter from "./rules/no-invisible-character"
+import noLazyEnds from "./rules/no-lazy-ends"
+import noLegacyFeatures from "./rules/no-legacy-features"
+import noMisleadingCapturingGroup from "./rules/no-misleading-capturing-group"
+import noMisleadingUnicodeCharacter from "./rules/no-misleading-unicode-character"
+import noMissingGFlag from "./rules/no-missing-g-flag"
+import noNonStandardFlag from "./rules/no-non-standard-flag"
+import noObscureRange from "./rules/no-obscure-range"
+import noOctal from "./rules/no-octal"
+import noOptionalAssertion from "./rules/no-optional-assertion"
+import noPotentiallyUselessBackreference from "./rules/no-potentially-useless-backreference"
+import noStandaloneBackslash from "./rules/no-standalone-backslash"
+import noSuperLinearBacktracking from "./rules/no-super-linear-backtracking"
+import noSuperLinearMove from "./rules/no-super-linear-move"
+import noTriviallyNestedAssertion from "./rules/no-trivially-nested-assertion"
+import noTriviallyNestedQuantifier from "./rules/no-trivially-nested-quantifier"
+import noUnusedCapturingGroup from "./rules/no-unused-capturing-group"
+import noUselessAssertions from "./rules/no-useless-assertions"
+import noUselessBackreference from "./rules/no-useless-backreference"
+import noUselessCharacterClass from "./rules/no-useless-character-class"
+import noUselessDollarReplacements from "./rules/no-useless-dollar-replacements"
+import noUselessEscape from "./rules/no-useless-escape"
+import noUselessFlag from "./rules/no-useless-flag"
+import noUselessLazy from "./rules/no-useless-lazy"
+import noUselessNonCapturingGroup from "./rules/no-useless-non-capturing-group"
+import noUselessQuantifier from "./rules/no-useless-quantifier"
+import noUselessRange from "./rules/no-useless-range"
+import noUselessSetOperand from "./rules/no-useless-set-operand"
+import noUselessStringLiteral from "./rules/no-useless-string-literal"
+import noUselessTwoNumsQuantifier from "./rules/no-useless-two-nums-quantifier"
+import noZeroQuantifier from "./rules/no-zero-quantifier"
+import optimalLookaroundQuantifier from "./rules/optimal-lookaround-quantifier"
+import optimalQuantifierConcatenation from "./rules/optimal-quantifier-concatenation"
+import preferCharacterClass from "./rules/prefer-character-class"
+import preferD from "./rules/prefer-d"
+import preferEscapeReplacementDollarChar from "./rules/prefer-escape-replacement-dollar-char"
+import preferLookaround from "./rules/prefer-lookaround"
+import preferNamedBackreference from "./rules/prefer-named-backreference"
+import preferNamedCaptureGroup from "./rules/prefer-named-capture-group"
+import preferNamedReplacement from "./rules/prefer-named-replacement"
+import preferPlusQuantifier from "./rules/prefer-plus-quantifier"
+import preferPredefinedAssertion from "./rules/prefer-predefined-assertion"
+import preferQuantifier from "./rules/prefer-quantifier"
+import preferQuestionQuantifier from "./rules/prefer-question-quantifier"
+import preferRange from "./rules/prefer-range"
+import preferRegexpExec from "./rules/prefer-regexp-exec"
+import preferRegexpTest from "./rules/prefer-regexp-test"
+import preferResultArrayGroups from "./rules/prefer-result-array-groups"
+import preferSetOperation from "./rules/prefer-set-operation"
+import preferStarQuantifier from "./rules/prefer-star-quantifier"
+import preferUnicodeCodepointEscapes from "./rules/prefer-unicode-codepoint-escapes"
+import preferW from "./rules/prefer-w"
+import requireUnicodeRegexp from "./rules/require-unicode-regexp"
+import requireUnicodeSetsRegexp from "./rules/require-unicode-sets-regexp"
+import simplifySetOperations from "./rules/simplify-set-operations"
+import sortAlternatives from "./rules/sort-alternatives"
+import sortCharacterClassElements from "./rules/sort-character-class-elements"
+import sortFlags from "./rules/sort-flags"
+import strict from "./rules/strict"
+import unicodeEscape from "./rules/unicode-escape"
+import useIgnoreCase from "./rules/use-ignore-case"
+
+export const rules: RuleModule[] = [
+    confusingQuantifier,
+    controlCharacterEscape,
+    graphemeStringLiteral,
+    hexadecimalEscape,
+    letterCase,
+    matchAny,
+    negation,
+    noContradictionWithAssertion,
+    noControlCharacter,
+    noDupeCharactersCharacterClass,
+    noDupeDisjunctions,
+    noEmptyAlternative,
+    noEmptyCapturingGroup,
+    noEmptyCharacterClass,
+    noEmptyGroup,
+    noEmptyLookaroundsAssertion,
+    noEmptyStringLiteral,
+    noEscapeBackspace,
+    noExtraLookaroundAssertions,
+    noInvalidRegexp,
+    noInvisibleCharacter,
+    noLazyEnds,
+    noLegacyFeatures,
+    noMisleadingCapturingGroup,
+    noMisleadingUnicodeCharacter,
+    noMissingGFlag,
+    noNonStandardFlag,
+    noObscureRange,
+    noOctal,
+    noOptionalAssertion,
+    noPotentiallyUselessBackreference,
+    noStandaloneBackslash,
+    noSuperLinearBacktracking,
+    noSuperLinearMove,
+    noTriviallyNestedAssertion,
+    noTriviallyNestedQuantifier,
+    noUnusedCapturingGroup,
+    noUselessAssertions,
+    noUselessBackreference,
+    noUselessCharacterClass,
+    noUselessDollarReplacements,
+    noUselessEscape,
+    noUselessFlag,
+    noUselessLazy,
+    noUselessNonCapturingGroup,
+    noUselessQuantifier,
+    noUselessRange,
+    noUselessSetOperand,
+    noUselessStringLiteral,
+    noUselessTwoNumsQuantifier,
+    noZeroQuantifier,
+    optimalLookaroundQuantifier,
+    optimalQuantifierConcatenation,
+    preferCharacterClass,
+    preferD,
+    preferEscapeReplacementDollarChar,
+    preferLookaround,
+    preferNamedBackreference,
+    preferNamedCaptureGroup,
+    preferNamedReplacement,
+    preferPlusQuantifier,
+    preferPredefinedAssertion,
+    preferQuantifier,
+    preferQuestionQuantifier,
+    preferRange,
+    preferRegexpExec,
+    preferRegexpTest,
+    preferResultArrayGroups,
+    preferSetOperation,
+    preferStarQuantifier,
+    preferUnicodeCodepointEscapes,
+    preferW,
+    requireUnicodeRegexp,
+    requireUnicodeSetsRegexp,
+    simplifySetOperations,
+    sortAlternatives,
+    sortCharacterClassElements,
+    sortFlags,
+    strict,
+    unicodeEscape,
+    useIgnoreCase,
+]

lib/configs/rules/all.ts

@@ -1,5 +1,5 @@
 import { rules as recommendedRules } from "./recommended"
-import { rules as ruleLint } from "../../utils/rules"
+import { rules as ruleLint } from "../../all-rules"
 
 const all: Record<string, string> = {}
 for (const rule of ruleLint) {

lib/index.ts

@@ -1,5 +1,5 @@
 import type { RuleModule } from "./types"
-import { rules as ruleList } from "./utils/rules"
+import { rules as ruleList } from "./all-rules"
 import * as recommended from "./configs/recommended"
 import * as all from "./configs/all"
 import * as flatRecommended from "./configs/flat/recommended"

lib/rules/confusing-quantifier.ts

@@ -1,12 +1,8 @@
 import type { RegExpVisitor } from "@eslint-community/regexpp/visitor"
 import type { RegExpContext } from "../utils"
-import {
-    createRule,
-    defineRegexpVisitor,
-    getQuantifierOffsets,
-    quantToString,
-} from "../utils"
+import { createRule, defineRegexpVisitor } from "../utils"
 import { isPotentiallyEmpty } from "regexp-ast-analysis"
+import { quantToString, getQuantifierOffsets } from "../utils/regexp-ast"
 
 export default createRule("confusing-quantifier", {
     meta: {

lib/rules/hexadecimal-escape.ts

@@ -1,12 +1,11 @@
 import type { RegExpVisitor } from "@eslint-community/regexpp/visitor"
 import type { Character } from "@eslint-community/regexpp/ast"
 import type { RegExpContext } from "../utils"
+import { defineRegexpVisitor, createRule } from "../utils"
 import {
-    defineRegexpVisitor,
-    createRule,
     getEscapeSequenceKind,
     EscapeSequenceKind,
-} from "../utils"
+} from "../utils/regex-syntax"
 
 export default createRule("hexadecimal-escape", {
     meta: {

lib/rules/letter-case.ts

@@ -10,9 +10,11 @@ import {
     isLetter,
     isLowercaseLetter,
     isUppercaseLetter,
+} from "../utils"
+import {
     EscapeSequenceKind,
     getEscapeSequenceKind,
-} from "../utils"
+} from "../utils/regex-syntax"
 
 const CASE_SCHEMA = ["lowercase", "uppercase", "ignore"] as const
 type Case = (typeof CASE_SCHEMA)[number]

lib/rules/no-contradiction-with-assertion.ts

@@ -6,7 +6,7 @@ import type {
     Quantifier,
 } from "@eslint-community/regexpp/ast"
 import type { RegExpContext } from "../utils"
-import { quantToString, createRule, defineRegexpVisitor } from "../utils"
+import { createRule, defineRegexpVisitor } from "../utils"
 import type {
     FirstLookChar,
     MatchingDirection,
@@ -21,6 +21,7 @@ import {
     isZeroLength,
     FirstConsumedChars,
 } from "regexp-ast-analysis"
+import { quantToString } from "../utils/regexp-ast"
 import { mention } from "../utils/mention"
 
 /**