eslint-plugin-perfectionist 2.11.0 → 3.0.0

package/dist/index.mjs

@@ -1,136 +1,91 @@
-import sortIntersectionTypes, { RULE_NAME as RULE_NAME$e } from "./rules/sort-intersection-types.mjs";
-import sortSvelteAttributes, { RULE_NAME as RULE_NAME$d } from "./rules/sort-svelte-attributes.mjs";
-import sortAstroAttributes, { RULE_NAME as RULE_NAME$1 } from "./rules/sort-astro-attributes.mjs";
-import sortArrayIncludes, { RULE_NAME } from "./rules/sort-array-includes.mjs";
-import sortVueAttributes, { RULE_NAME as RULE_NAME$g } from "./rules/sort-vue-attributes.mjs";
-import sortNamedExports, { RULE_NAME as RULE_NAME$9 } from "./rules/sort-named-exports.mjs";
-import sortNamedImports, { RULE_NAME as RULE_NAME$a } from "./rules/sort-named-imports.mjs";
-import sortObjectTypes, { RULE_NAME as RULE_NAME$b } from "./rules/sort-object-types.mjs";
-import sortUnionTypes, { RULE_NAME as RULE_NAME$f } from "./rules/sort-union-types.mjs";
-import sortInterfaces, { RULE_NAME as RULE_NAME$6 } from "./rules/sort-interfaces.mjs";
-import sortJsxProps, { RULE_NAME as RULE_NAME$7 } from "./rules/sort-jsx-props.mjs";
-import sortExports, { RULE_NAME as RULE_NAME$4 } from "./rules/sort-exports.mjs";
-import sortImports, { RULE_NAME as RULE_NAME$5 } from "./rules/sort-imports.mjs";
-import sortObjects, { RULE_NAME as RULE_NAME$c } from "./rules/sort-objects.mjs";
-import sortClasses, { RULE_NAME as RULE_NAME$2 } from "./rules/sort-classes.mjs";
-import sortEnums, { RULE_NAME as RULE_NAME$3 } from "./rules/sort-enums.mjs";
-import sortMaps, { RULE_NAME as RULE_NAME$8 } from "./rules/sort-maps.mjs";
-import { SortType, SortOrder } from "./typings/index.mjs";
-import { name } from "./package.json.mjs";
-let createConfigWithOptions = (options) => {
-  let recommendedRules = {
-    [RULE_NAME$5]: [
-      "error",
-      {
-        groups: [
-          "type",
-          ["builtin", "external"],
-          "internal-type",
-          "internal",
-          ["parent-type", "sibling-type", "index-type"],
-          ["parent", "sibling", "index"],
-          "object",
-          "unknown"
-        ],
-        "custom-groups": {
-          value: {},
-          type: {}
-        },
-        "newlines-between": "always",
-        "internal-pattern": ["~/**"]
-      }
-    ],
-    [RULE_NAME$2]: [
-      "error",
-      {
-        groups: [
-          "index-signature",
-          "static-property",
-          "private-property",
-          "property",
-          "constructor",
-          "static-method",
-          "private-method",
-          "method",
-          ["get-method", "set-method"],
-          "unknown"
-        ]
-      }
-    ],
-    [RULE_NAME$c]: [
-      "error",
-      {
-        "partition-by-comment": false
-      }
-    ],
-    [RULE_NAME]: [
-      "error",
-      {
-        "spread-last": true
-      }
-    ],
-    [RULE_NAME$e]: ["error"],
-    [RULE_NAME$d]: ["error"],
-    [RULE_NAME$1]: ["error"],
-    [RULE_NAME$g]: ["error"],
-    [RULE_NAME$9]: ["error"],
-    [RULE_NAME$a]: ["error"],
-    [RULE_NAME$b]: ["error"],
-    [RULE_NAME$f]: ["error"],
-    [RULE_NAME$6]: ["error"],
-    [RULE_NAME$7]: ["error"],
-    [RULE_NAME$4]: ["error"],
-    [RULE_NAME$3]: ["error"],
-    [RULE_NAME$8]: ["error"]
-  };
-  return {
-    rules: Object.fromEntries(
-      Object.entries(recommendedRules).map(([key, [message, baseOptions = {}]]) => [
-        `perfectionist/${key}`,
-        [message, Object.assign(baseOptions, options)]
-      ])
-    ),
-    plugins: ["perfectionist"]
-  };
-};
-const mod = {
+import sortVariableDeclarations from './rules/sort-variable-declarations.mjs'
+import sortIntersectionTypes from './rules/sort-intersection-types.mjs'
+import sortSvelteAttributes from './rules/sort-svelte-attributes.mjs'
+import sortAstroAttributes from './rules/sort-astro-attributes.mjs'
+import sortArrayIncludes from './rules/sort-array-includes.mjs'
+import sortVueAttributes from './rules/sort-vue-attributes.mjs'
+import sortNamedImports from './rules/sort-named-imports.mjs'
+import sortNamedExports from './rules/sort-named-exports.mjs'
+import sortObjectTypes from './rules/sort-object-types.mjs'
+import sortSwitchCase from './rules/sort-switch-case.mjs'
+import sortUnionTypes from './rules/sort-union-types.mjs'
+import sortInterfaces from './rules/sort-interfaces.mjs'
+import sortJsxProps from './rules/sort-jsx-props.mjs'
+import sortClasses from './rules/sort-classes.mjs'
+import sortImports from './rules/sort-imports.mjs'
+import sortExports from './rules/sort-exports.mjs'
+import sortObjects from './rules/sort-objects.mjs'
+import sortEnums from './rules/sort-enums.mjs'
+import sortMaps from './rules/sort-maps.mjs'
+let name = 'perfectionist'
+let plugin = {
   rules: {
-    [RULE_NAME]: sortArrayIncludes,
-    [RULE_NAME$1]: sortAstroAttributes,
-    [RULE_NAME$2]: sortClasses,
-    [RULE_NAME$3]: sortEnums,
-    [RULE_NAME$4]: sortExports,
-    [RULE_NAME$5]: sortImports,
-    [RULE_NAME$6]: sortInterfaces,
-    [RULE_NAME$7]: sortJsxProps,
-    [RULE_NAME$8]: sortMaps,
-    [RULE_NAME$9]: sortNamedExports,
-    [RULE_NAME$a]: sortNamedImports,
-    [RULE_NAME$b]: sortObjectTypes,
-    [RULE_NAME$c]: sortObjects,
-    [RULE_NAME$d]: sortSvelteAttributes,
-    [RULE_NAME$e]: sortIntersectionTypes,
-    [RULE_NAME$f]: sortUnionTypes,
-    [RULE_NAME$g]: sortVueAttributes
+    'sort-variable-declarations': sortVariableDeclarations,
+    'sort-intersection-types': sortIntersectionTypes,
+    'sort-svelte-attributes': sortSvelteAttributes,
+    'sort-astro-attributes': sortAstroAttributes,
+    'sort-vue-attributes': sortVueAttributes,
+    'sort-array-includes': sortArrayIncludes,
+    'sort-named-imports': sortNamedImports,
+    'sort-named-exports': sortNamedExports,
+    'sort-object-types': sortObjectTypes,
+    'sort-union-types': sortUnionTypes,
+    'sort-switch-case': sortSwitchCase,
+    'sort-interfaces': sortInterfaces,
+    'sort-jsx-props': sortJsxProps,
+    'sort-classes': sortClasses,
+    'sort-imports': sortImports,
+    'sort-exports': sortExports,
+    'sort-objects': sortObjects,
+    'sort-enums': sortEnums,
+    'sort-maps': sortMaps,
   },
+  name,
+}
+let getRules = options =>
+  Object.fromEntries(
+    Object.keys(plugin.rules).map(rule => [
+      `${name}/${rule}`,
+      ['error', options],
+    ]),
+  )
+let createConfig = options => ({
+  plugins: {
+    [name]: plugin,
+  },
+  rules: getRules(options),
+})
+let createLegacyConfig = options => ({
+  rules: getRules(options),
+  plugins: [name],
+})
+const index = {
+  ...plugin,
   configs: {
-    "recommended-alphabetical": createConfigWithOptions({
-      type: SortType.alphabetical,
-      order: SortOrder.asc,
-      "ignore-case": false
+    'recommended-alphabetical-legacy': createLegacyConfig({
+      type: 'alphabetical',
+      order: 'asc',
+    }),
+    'recommended-line-length-legacy': createLegacyConfig({
+      type: 'line-length',
+      order: 'desc',
+    }),
+    'recommended-natural-legacy': createLegacyConfig({
+      type: 'natural',
+      order: 'asc',
+    }),
+    'recommended-alphabetical': createConfig({
+      type: 'alphabetical',
+      order: 'asc',
+    }),
+    'recommended-line-length': createConfig({
+      type: 'line-length',
+      order: 'desc',
     }),
-    "recommended-natural": createConfigWithOptions({
-      type: SortType.natural,
-      order: SortOrder.asc,
-      "ignore-case": false
+    'recommended-natural': createConfig({
+      type: 'natural',
+      order: 'asc',
     }),
-    "recommended-line-length": createConfigWithOptions({
-      type: SortType["line-length"],
-      order: SortOrder.desc
-    })
   },
-  name
-};
-export {
-  mod as default
-};
+}
+export { index as default }

package/dist/rules/sort-array-includes.js

@@ -1,129 +1,155 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const createEslintRule = require("../utils/create-eslint-rule.js");
-const toSingleLine = require("../utils/to-single-line.js");
-const rangeToDiff = require("../utils/range-to-diff.js");
-const isPositive = require("../utils/is-positive.js");
-const index = require("../typings/index.js");
-const sortNodes = require("../utils/sort-nodes.js");
-const makeFixes = require("../utils/make-fixes.js");
-const complete = require("../utils/complete.js");
-const pairwise = require("../utils/pairwise.js");
-const compare = require("../utils/compare.js");
-const RULE_NAME = "sort-array-includes";
+'use strict'
+const createEslintRule = require('../utils/create-eslint-rule.js')
+const getGroupNumber = require('../utils/get-group-number.js')
+const getSourceCode = require('../utils/get-source-code.js')
+const toSingleLine = require('../utils/to-single-line.js')
+const rangeToDiff = require('../utils/range-to-diff.js')
+const isPositive = require('../utils/is-positive.js')
+const sortNodes = require('../utils/sort-nodes.js')
+const makeFixes = require('../utils/make-fixes.js')
+const complete = require('../utils/complete.js')
+const pairwise = require('../utils/pairwise.js')
+const compare = require('../utils/compare.js')
 const sortArrayIncludes = createEslintRule.createEslintRule({
-  name: RULE_NAME,
+  name: 'sort-array-includes',
   meta: {
-    type: "suggestion",
+    type: 'suggestion',
     docs: {
-      description: "enforce sorted arrays before include method"
+      description: 'Enforce sorted arrays before include method.',
     },
-    fixable: "code",
+    fixable: 'code',
     schema: [
       {
-        type: "object",
+        type: 'object',
         properties: {
           type: {
-            enum: [
-              index.SortType.alphabetical,
-              index.SortType.natural,
-              index.SortType["line-length"]
-            ],
-            default: index.SortType.alphabetical,
-            type: "string"
+            description: 'Specifies the sorting method.',
+            type: 'string',
+            enum: ['alphabetical', 'natural', 'line-length'],
           },
           order: {
-            enum: [index.SortOrder.asc, index.SortOrder.desc],
-            default: index.SortOrder.asc,
-            type: "string"
+            description:
+              'Determines whether the sorted items should be in ascending or descending order.',
+            type: 'string',
+            enum: ['asc', 'desc'],
           },
-          "ignore-case": {
-            type: "boolean",
-            default: false
+          ignoreCase: {
+            description:
+              'Controls whether sorting should be case-sensitive or not.',
+            type: 'boolean',
+          },
+          groupKind: {
+            description: 'Specifies top-level groups.',
+            enum: ['mixed', 'literals-first', 'spreads-first'],
+            type: 'string',
           },
-          "spread-last": {
-            type: "boolean",
-            default: false
-          }
         },
-        additionalProperties: false
-      }
+        additionalProperties: false,
+      },
     ],
     messages: {
-      unexpectedArrayIncludesOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
+      unexpectedArrayIncludesOrder:
+        'Expected "{{right}}" to come before "{{left}}".',
+    },
   },
   defaultOptions: [
     {
-      type: index.SortType.alphabetical,
-      order: index.SortOrder.asc
-    }
+      type: 'alphabetical',
+      order: 'asc',
+      ignoreCase: true,
+      groupKind: 'literals-first',
+    },
   ],
-  create: (context) => ({
-    MemberExpression: (node) => {
-      if ((node.object.type === "ArrayExpression" || node.object.type === "NewExpression") && node.property.type === "Identifier" && node.property.name === "includes") {
-        let elements = node.object.type === "ArrayExpression" ? node.object.elements : node.object.arguments;
+  create: context => ({
+    MemberExpression: node => {
+      if (
+        (node.object.type === 'ArrayExpression' ||
+          node.object.type === 'NewExpression') &&
+        node.property.type === 'Identifier' &&
+        node.property.name === 'includes'
+      ) {
+        let elements =
+          node.object.type === 'ArrayExpression'
+            ? node.object.elements
+            : node.object.arguments
         if (elements.length > 1) {
           let options = complete.complete(context.options.at(0), {
-            type: index.SortType.alphabetical,
-            order: index.SortOrder.asc,
-            "ignore-case": false,
-            "spread-last": false
-          });
-          let nodes = elements.reduce(
-            (accumulator, element) => {
-              if (element !== null) {
-                accumulator.at(0).push({
-                  name: element.type === "Literal" ? `${element.value}` : context.sourceCode.text.slice(...element.range),
-                  size: rangeToDiff.rangeToDiff(element.range),
-                  type: element.type,
-                  node: element
-                });
-              }
-              return accumulator;
-            },
-            [[], []]
-          ).flat();
+            groupKind: 'literals-first',
+            type: 'alphabetical',
+            ignoreCase: true,
+            order: 'asc',
+          })
+          let sourceCode = getSourceCode.getSourceCode(context)
+          let nodes = elements
+            .reduce(
+              (accumulator, element) => {
+                if (element !== null) {
+                  let group = 'unknown'
+                  if (typeof options.groupKind === 'string') {
+                    group =
+                      element.type === 'SpreadElement' ? 'spread' : 'literal'
+                  }
+                  accumulator.at(0).push({
+                    name:
+                      element.type === 'Literal'
+                        ? `${element.value}`
+                        : sourceCode.text.slice(...element.range),
+                    size: rangeToDiff.rangeToDiff(element.range),
+                    type: element.type,
+                    node: element,
+                    group,
+                  })
+                }
+                return accumulator
+              },
+              [[], []],
+            )
+            .flat()
           pairwise.pairwise(nodes, (left, right) => {
-            let compareValue;
-            if (options["spread-last"] && left.node.type === "Literal" && right.node.type === "SpreadElement") {
-              compareValue = false;
-            } else if (options["spread-last"] && left.node.type === "SpreadElement" && right.node.type === "Literal") {
-              compareValue = true;
-            } else {
-              compareValue = isPositive.isPositive(compare.compare(left, right, options));
+            let groupKindOrder = ['unknown']
+            if (typeof options.groupKind === 'string') {
+              groupKindOrder =
+                options.groupKind === 'literals-first'
+                  ? ['literal', 'spread']
+                  : ['spread', 'literal']
             }
-            if (compareValue) {
+            let leftNum = getGroupNumber.getGroupNumber(groupKindOrder, left)
+            let rightNum = getGroupNumber.getGroupNumber(groupKindOrder, right)
+            if (
+              (options.groupKind !== 'mixed' && leftNum > rightNum) ||
+              ((options.groupKind === 'mixed' || leftNum === rightNum) &&
+                isPositive.isPositive(compare.compare(left, right, options)))
+            ) {
               context.report({
-                messageId: "unexpectedArrayIncludesOrder",
+                messageId: 'unexpectedArrayIncludesOrder',
                 data: {
                   left: toSingleLine.toSingleLine(left.name),
-                  right: toSingleLine.toSingleLine(right.name)
+                  right: toSingleLine.toSingleLine(right.name),
                 },
                 node: right.node,
-                fix: (fixer) => {
-                  let sortedNodes = sortNodes.sortNodes(nodes, options);
-                  if (options["spread-last"]) {
-                    for (let i = 0, max = sortedNodes.length; i < max; i++) {
-                      if (sortedNodes.at(i).node.type === "SpreadElement") {
-                        sortedNodes.push(sortedNodes.splice(i, 1).at(0));
-                      }
-                    }
-                  }
+                fix: fixer => {
+                  let sortedNodes =
+                    options.groupKind !== 'mixed'
+                      ? groupKindOrder
+                          .map(group => nodes.filter(n => n.group === group))
+                          .map(groupedNodes =>
+                            sortNodes.sortNodes(groupedNodes, options),
+                          )
+                          .flat()
+                      : sortNodes.sortNodes(nodes, options)
                   return makeFixes.makeFixes(
                     fixer,
                     nodes,
                     sortedNodes,
-                    context.sourceCode
-                  );
-                }
-              });
+                    sourceCode,
+                  )
+                },
+              })
             }
-          });
+          })
         }
       }
-    }
-  })
-});
-exports.RULE_NAME = RULE_NAME;
-exports.default = sortArrayIncludes;
+    },
+  }),
+})
+module.exports = sortArrayIncludes