eslint-plugin-perfectionist 4.2.0 → 4.3.0

package/dist/utils/common-json-schemas.js

@@ -1,7 +1,7 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 let typeJsonSchema = {
-  enum: ['alphabetical', 'natural', 'line-length'],
+  enum: ['alphabetical', 'natural', 'line-length', 'custom'],
   description: 'Specifies the sorting method.',
   type: 'string',
 }
@@ -11,6 +11,10 @@ let orderJsonSchema = {
   enum: ['asc', 'desc'],
   type: 'string',
 }
+let alphabetJsonSchema = {
+  description: 'Alphabet to use for the `custom` sort type.',
+  type: 'string',
+}
 let localesJsonSchema = {
   oneOf: [
     {
@@ -96,6 +100,15 @@ let newlinesBetweenJsonSchema = {
   enum: ['ignore', 'always', 'never'],
   type: 'string',
 }
+let useConfigurationIfJsonSchema = {
+  properties: {
+    allNamesMatchPattern: {
+      type: 'string',
+    },
+  },
+  additionalProperties: false,
+  type: 'object',
+}
 let customGroupSortJsonSchema = {
   type: {
     enum: ['alphabetical', 'line-length', 'natural', 'unsorted'],
@@ -169,6 +182,7 @@ let elementNamePatternJsonSchema = {
   description: 'Element name pattern filter.',
   type: 'string',
 }
+exports.alphabetJsonSchema = alphabetJsonSchema
 exports.buildCustomGroupModifiersJsonSchema =
   buildCustomGroupModifiersJsonSchema
 exports.buildCustomGroupSelectorJsonSchema = buildCustomGroupSelectorJsonSchema
@@ -184,3 +198,4 @@ exports.partitionByCommentJsonSchema = partitionByCommentJsonSchema
 exports.partitionByNewLineJsonSchema = partitionByNewLineJsonSchema
 exports.specialCharactersJsonSchema = specialCharactersJsonSchema
 exports.typeJsonSchema = typeJsonSchema
+exports.useConfigurationIfJsonSchema = useConfigurationIfJsonSchema

package/dist/utils/compare.js

@@ -1,53 +1,103 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 const naturalOrderby = require('natural-orderby')
+const convertBooleanToSign = require('./convert-boolean-to-sign.js')
+let alphabetCache = /* @__PURE__ */ new Map()
 let compare = (a, b, options) => {
-  let orderCoefficient = options.order === 'asc' ? 1 : -1
   let sortingFunction
   let nodeValueGetter = options.nodeValueGetter ?? (node => node.name)
-  if (options.type === 'alphabetical') {
-    let formatString = getFormatStringFunction(
-      options.ignoreCase,
-      options.specialCharacters,
+  switch (options.type) {
+    case 'alphabetical':
+      sortingFunction = getAlphabeticalSortingFunction(options, nodeValueGetter)
+      break
+    case 'natural':
+      sortingFunction = getNaturalSortingFunction(options, nodeValueGetter)
+      break
+    case 'custom':
+      sortingFunction = getCustomSortingFunction(options, nodeValueGetter)
+      break
+    case 'line-length':
+      sortingFunction = getLineLengthSortingFunction(options, nodeValueGetter)
+  }
+  return (
+    convertBooleanToSign.convertBooleanToSign(options.order === 'asc') *
+    sortingFunction(a, b)
+  )
+}
+let getAlphabeticalSortingFunction = (
+  { specialCharacters, ignoreCase, locales },
+  nodeValueGetter,
+) => {
+  let formatString = getFormatStringFunction(ignoreCase, specialCharacters)
+  return (aNode, bNode) =>
+    formatString(nodeValueGetter(aNode)).localeCompare(
+      formatString(nodeValueGetter(bNode)),
+      locales,
     )
-    sortingFunction = (aNode, bNode) =>
-      formatString(nodeValueGetter(aNode)).localeCompare(
-        formatString(nodeValueGetter(bNode)),
-        options.locales,
-      )
-  } else if (options.type === 'natural') {
-    let naturalCompare = naturalOrderby.compare({
-      locale: options.locales.toString(),
-    })
-    let formatString = getFormatStringFunction(
-      options.ignoreCase,
-      options.specialCharacters,
+}
+let getNaturalSortingFunction = (
+  { specialCharacters, ignoreCase, locales },
+  nodeValueGetter,
+) => {
+  let naturalCompare = naturalOrderby.compare({
+    locale: locales.toString(),
+  })
+  let formatString = getFormatStringFunction(ignoreCase, specialCharacters)
+  return (aNode, bNode) =>
+    naturalCompare(
+      formatString(nodeValueGetter(aNode)),
+      formatString(nodeValueGetter(bNode)),
     )
-    sortingFunction = (aNode, bNode) =>
-      naturalCompare(
-        formatString(nodeValueGetter(aNode)),
-        formatString(nodeValueGetter(bNode)),
-      )
-  } else {
-    sortingFunction = (aNode, bNode) => {
-      let aSize = aNode.size
-      let bSize = bNode.size
-      let { maxLineLength } = options
-      if (maxLineLength) {
-        let isTooLong = (size, node) =>
-          size > maxLineLength && node.hasMultipleImportDeclarations
-        if (isTooLong(aSize, aNode)) {
-          aSize = nodeValueGetter(aNode).length + 10
-        }
-        if (isTooLong(bSize, bNode)) {
-          bSize = nodeValueGetter(bNode).length + 10
-        }
+}
+let getCustomSortingFunction = (
+  { specialCharacters, ignoreCase, alphabet },
+  nodeValueGetter,
+) => {
+  let formatString = getFormatStringFunction(ignoreCase, specialCharacters)
+  let indexByCharacters = alphabetCache.get(alphabet)
+  if (!indexByCharacters) {
+    indexByCharacters = /* @__PURE__ */ new Map()
+    for (let [index, character] of [...alphabet].entries()) {
+      indexByCharacters.set(character, index)
+    }
+    alphabetCache.set(alphabet, indexByCharacters)
+  }
+  return (aNode, bNode) => {
+    let aValue = formatString(nodeValueGetter(aNode))
+    let bValue = formatString(nodeValueGetter(bNode))
+    for (let i = 0; i < aValue.length; i++) {
+      let aCharacter = aValue[i]
+      let bCharacter = bValue[i]
+      let indexOfA = indexByCharacters.get(aCharacter)
+      let indexOfB = indexByCharacters.get(bCharacter)
+      indexOfA ?? (indexOfA = Infinity)
+      indexOfB ?? (indexOfB = Infinity)
+      if (indexOfA !== indexOfB) {
+        return convertBooleanToSign.convertBooleanToSign(
+          indexOfA - indexOfB > 0,
+        )
       }
-      return aSize - bSize
     }
+    return 0
   }
-  return orderCoefficient * sortingFunction(a, b)
 }
+let getLineLengthSortingFunction =
+  ({ maxLineLength }, nodeValueGetter) =>
+  (aNode, bNode) => {
+    let aSize = aNode.size
+    let bSize = bNode.size
+    if (maxLineLength) {
+      let isTooLong = (size, node) =>
+        size > maxLineLength && node.hasMultipleImportDeclarations
+      if (isTooLong(aSize, aNode)) {
+        aSize = nodeValueGetter(aNode).length + 10
+      }
+      if (isTooLong(bSize, bNode)) {
+        bSize = nodeValueGetter(bNode).length + 10
+      }
+    }
+    return aSize - bSize
+  }
 let getFormatStringFunction = (ignoreCase, specialCharacters) => value => {
   let valueToCompare = value
   if (ignoreCase) {

package/dist/utils/convert-boolean-to-sign.js

@@ -0,0 +1,4 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+let convertBooleanToSign = value => (value ? 1 : -1)
+exports.convertBooleanToSign = convertBooleanToSign

package/dist/{rules → utils}/get-custom-groups-compare-options.js

@@ -22,6 +22,7 @@ let getCustomGroupsCompareOptions = (options, groupNumber) => {
     specialCharacters: options.specialCharacters,
     type: (customGroup == null ? void 0 : customGroup.type) ?? options.type,
     ignoreCase: options.ignoreCase,
+    alphabet: options.alphabet,
     locales: options.locales,
   }
 }

package/dist/utils/get-matching-context-options.js

@@ -0,0 +1,18 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const matches = require('./matches.js')
+let getMatchingContextOptions = ({ contextOptions, nodeNames }) =>
+  contextOptions.find(options => {
+    var _a
+    let allNamesMatchPattern =
+      (_a = options.useConfigurationIf) == null
+        ? void 0
+        : _a.allNamesMatchPattern
+    return (
+      !allNamesMatchPattern ||
+      nodeNames.every(nodeName =>
+        matches.matches(nodeName, allNamesMatchPattern),
+      )
+    )
+  })
+exports.getMatchingContextOptions = getMatchingContextOptions

package/dist/utils/get-settings.js

@@ -11,6 +11,7 @@ let getSettings = (settings = {}) => {
       'specialCharacters',
       'ignorePattern',
       'ignoreCase',
+      'alphabet',
       'locales',
       'order',
       'type',

package/dist/utils/is-node-function-type.js

@@ -0,0 +1,15 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+let isNodeFunctionType = node => {
+  if (node.type === 'TSMethodSignature' || node.type === 'TSFunctionType') {
+    return true
+  }
+  if (node.type === 'TSUnionType' || node.type === 'TSIntersectionType') {
+    return node.types.every(isNodeFunctionType)
+  }
+  if (node.type === 'TSPropertySignature' && node.typeAnnotation) {
+    return isNodeFunctionType(node.typeAnnotation.typeAnnotation)
+  }
+  return false
+}
+exports.isNodeFunctionType = isNodeFunctionType

package/dist/utils/validate-custom-sort-configuration.js

@@ -0,0 +1,11 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+let validateCustomSortConfiguration = ({ alphabet, type }) => {
+  if (type !== 'custom') {
+    return
+  }
+  if (!alphabet.length) {
+    throw new Error('`alphabet` option must not be empty')
+  }
+}
+exports.validateCustomSortConfiguration = validateCustomSortConfiguration

package/dist/{rules → utils}/validate-generated-groups-configuration.js

@@ -1,6 +1,6 @@
 'use strict'
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
-const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
+const validateGroupsConfiguration = require('./validate-groups-configuration.js')
 let validateGeneratedGroupsConfiguration = ({
   customGroups,
   selectors,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-perfectionist",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "ESLint plugin for sorting various data such as objects, imports, types, enums, JSX props, etc.",
   "keywords": [
     "eslint",
@@ -17,14 +17,18 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./alphabet": {
+      "types": "./dist/alphabet.d.ts",
+      "default": "./dist/utils/alphabet.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "./dist"
   ],
   "dependencies": {
-    "@typescript-eslint/types": "^8.17.0",
-    "@typescript-eslint/utils": "^8.17.0",
+    "@typescript-eslint/types": "^8.18.0",
+    "@typescript-eslint/utils": "^8.18.0",
     "natural-orderby": "^5.0.0"
   },
   "peerDependencies": {

package/readme.md

@@ -165,6 +165,7 @@ module.exports = {
 | [recommended-alphabetical](https://perfectionist.dev/configs/recommended-alphabetical) | All plugin rules with alphabetical sorting in ascending order    |
 | [recommended-natural](https://perfectionist.dev/configs/recommended-natural)           | All plugin rules with natural sorting in ascending order         |
 | [recommended-line-length](https://perfectionist.dev/configs/recommended-line-length)   | All plugin rules with sorting by line length in descending order |
+| [recommended-custom](https://perfectionist.dev/configs/recommended-custom)             | All plugin rules with sorting by your own custom order           |
 
 ## Rules
 
@@ -201,15 +202,15 @@ module.exports = {
 
 ### Can I automatically fix problems in the editor?
 
-Yes. To do this, you need to enable autofix in ESLint when you save the file in your editor. Instructions for your editor can be found [here](https://perfectionist.dev/guide/integrations).
+Yes. To do this, you need to enable autofix in ESLint when you save the file in your editor. You may find instructions for your editor can be found [here](https://perfectionist.dev/guide/integrations).
 
 ### Is it safe?
 
-On the whole, yes. We are very careful to make sure that the work of the plugin does not negatively affect the work of the code. For example, the plugin takes into account spread operators in JSX and objects, comments to the code. Safety is our priority. If you encounter any problem, you can create an [issue](https://github.com/azat-io/eslint-plugin-perfectionist/issues/new/choose).
+Overall, yes. We want to make sure that the work of the plugin does not negatively affect the behavior of the code. For example, the plugin takes into account spread operators in JSX and objects, comments to the code. Safety is our priority. If you encounter any problem, you can create an [issue](https://github.com/azat-io/eslint-plugin-perfectionist/issues/new/choose).
 
 ### Why not Prettier?
 
-I love Prettier. However, this is not his area of responsibility. Prettier is used for formatting, and ESLint is also used for styling. For example, changing the order of imports can affect how the code works (console.log calls, fetch, style loading). Prettier should not change the AST. There is a cool article about this: ["The Blurry Line Between Formatting and Style"](https://blog.joshuakgoldberg.com/the-blurry-line-between-formatting-and-style) by **@joshuakgoldberg**.
+I love Prettier. However, this is not its area of responsibility. Prettier is used for formatting, and ESLint is also used for styling. For example, changing the order of imports can affect how the code works (console.log calls, fetch, style loading). Prettier should not change the AST. There is a cool article about this: ["The Blurry Line Between Formatting and Style"](https://blog.joshuakgoldberg.com/the-blurry-line-between-formatting-and-style) by **@joshuakgoldberg**.
 
 ## Versioning Policy