eslint-plugin-perfectionist 2.7.0 → 2.9.0

package/dist/rules/sort-jsx-props.mjs

@@ -0,0 +1,156 @@
+import path from "node:path";
+import { createEslintRule } from "../utils/create-eslint-rule.mjs";
+import { getGroupNumber } from "../utils/get-group-number.mjs";
+import { rangeToDiff } from "../utils/range-to-diff.mjs";
+import { isPositive } from "../utils/is-positive.mjs";
+import { SortType, SortOrder } from "../typings/index.mjs";
+import { useGroups } from "../utils/use-groups.mjs";
+import { makeFixes } from "../utils/make-fixes.mjs";
+import { sortNodes } from "../utils/sort-nodes.mjs";
+import { pairwise } from "../utils/pairwise.mjs";
+import { complete } from "../utils/complete.mjs";
+import { compare } from "../utils/compare.mjs";
+const RULE_NAME = "sort-jsx-props";
+const sortJsxProps = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted JSX props"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          "custom-groups": {
+            type: "object"
+          },
+          type: {
+            enum: [
+              SortType.alphabetical,
+              SortType.natural,
+              SortType["line-length"]
+            ],
+            default: SortType.alphabetical,
+            type: "string"
+          },
+          order: {
+            enum: [SortOrder.asc, SortOrder.desc],
+            default: SortOrder.asc,
+            type: "string"
+          },
+          groups: {
+            type: "array"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedJSXPropsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  create: (context) => {
+    if ([".svelte", ".astro", ".vue"].includes(path.extname(context.filename))) {
+      return {};
+    }
+    return {
+      JSXElement: (node) => {
+        if (node.openingElement.attributes.length > 1) {
+          let options = complete(context.options.at(0), {
+            type: SortType.alphabetical,
+            "ignore-case": false,
+            order: SortOrder.asc,
+            "custom-groups": {},
+            groups: []
+          });
+          let parts = node.openingElement.attributes.reduce(
+            (accumulator, attribute) => {
+              if (attribute.type === "JSXSpreadAttribute") {
+                accumulator.push([]);
+                return accumulator;
+              }
+              let name = attribute.name.type === "JSXNamespacedName" ? `${attribute.name.namespace.name}:${attribute.name.name.name}` : attribute.name.name;
+              let { getGroup, defineGroup, setCustomGroups } = useGroups(
+                options.groups
+              );
+              setCustomGroups(options["custom-groups"], name);
+              if (attribute.value === null) {
+                defineGroup("shorthand");
+              }
+              if (attribute.loc.start.line !== attribute.loc.end.line) {
+                defineGroup("multiline");
+              }
+              let jsxNode = {
+                size: rangeToDiff(attribute.range),
+                group: getGroup(),
+                node: attribute,
+                name
+              };
+              accumulator.at(-1).push(jsxNode);
+              return accumulator;
+            },
+            [[]]
+          );
+          for (let nodes of parts) {
+            pairwise(nodes, (left, right) => {
+              let leftNum = getGroupNumber(options.groups, left);
+              let rightNum = getGroupNumber(options.groups, right);
+              if (leftNum > rightNum || leftNum === rightNum && isPositive(compare(left, right, options))) {
+                context.report({
+                  messageId: "unexpectedJSXPropsOrder",
+                  data: {
+                    left: left.name,
+                    right: right.name
+                  },
+                  node: right.node,
+                  fix: (fixer) => {
+                    let grouped = {};
+                    for (let currentNode of nodes) {
+                      let groupNum = getGroupNumber(options.groups, currentNode);
+                      if (!(groupNum in grouped)) {
+                        grouped[groupNum] = [currentNode];
+                      } else {
+                        grouped[groupNum] = sortNodes(
+                          [...grouped[groupNum], currentNode],
+                          options
+                        );
+                      }
+                    }
+                    let sortedNodes = [];
+                    for (let group of Object.keys(grouped).sort(
+                      (a, b) => Number(a) - Number(b)
+                    )) {
+                      sortedNodes.push(...sortNodes(grouped[group], options));
+                    }
+                    return makeFixes(
+                      fixer,
+                      nodes,
+                      sortedNodes,
+                      context.sourceCode
+                    );
+                  }
+                });
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+export {
+  RULE_NAME,
+  sortJsxProps as default
+};

package/dist/rules/sort-maps.js

@@ -0,0 +1,125 @@
+"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-maps";
+const sortMaps = createEslintRule.createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted Map elements"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          type: {
+            enum: [
+              index.SortType.alphabetical,
+              index.SortType.natural,
+              index.SortType["line-length"]
+            ],
+            default: index.SortType.alphabetical,
+            type: "string"
+          },
+          order: {
+            enum: [index.SortOrder.asc, index.SortOrder.desc],
+            default: index.SortOrder.asc,
+            type: "string"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedMapElementsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    NewExpression: (node) => {
+      if (node.callee.type === "Identifier" && node.callee.name === "Map" && node.arguments.length && node.arguments[0].type === "ArrayExpression") {
+        let [{ elements }] = node.arguments;
+        if (elements.length > 1) {
+          let options = complete.complete(context.options.at(0), {
+            type: index.SortType.alphabetical,
+            "ignore-case": false,
+            order: index.SortOrder.asc
+          });
+          let parts = elements.reduce(
+            (accumulator, element) => {
+              if (element === null || element.type === "SpreadElement") {
+                accumulator.push([]);
+              } else {
+                accumulator.at(-1).push(element);
+              }
+              return accumulator;
+            },
+            [[]]
+          );
+          for (let part of parts) {
+            let nodes = part.map((element) => {
+              let name;
+              if (element.type === "ArrayExpression") {
+                let [left] = element.elements;
+                if (!left) {
+                  name = `${left}`;
+                } else if (left.type === "Literal") {
+                  name = left.raw;
+                } else {
+                  name = context.sourceCode.text.slice(...left.range);
+                }
+              } else {
+                name = context.sourceCode.text.slice(...element.range);
+              }
+              return {
+                size: rangeToDiff.rangeToDiff(element.range),
+                node: element,
+                name
+              };
+            });
+            pairwise.pairwise(nodes, (left, right) => {
+              if (isPositive.isPositive(compare.compare(left, right, options))) {
+                context.report({
+                  messageId: "unexpectedMapElementsOrder",
+                  data: {
+                    left: toSingleLine.toSingleLine(left.name),
+                    right: toSingleLine.toSingleLine(right.name)
+                  },
+                  node: right.node,
+                  fix: (fixer) => makeFixes.makeFixes(
+                    fixer,
+                    nodes,
+                    sortNodes.sortNodes(nodes, options),
+                    context.sourceCode
+                  )
+                });
+              }
+            });
+          }
+        }
+      }
+    }
+  })
+});
+exports.RULE_NAME = RULE_NAME;
+exports.default = sortMaps;

package/dist/rules/sort-maps.mjs

@@ -0,0 +1,125 @@
+import { createEslintRule } from "../utils/create-eslint-rule.mjs";
+import { toSingleLine } from "../utils/to-single-line.mjs";
+import { rangeToDiff } from "../utils/range-to-diff.mjs";
+import { isPositive } from "../utils/is-positive.mjs";
+import { SortType, SortOrder } from "../typings/index.mjs";
+import { sortNodes } from "../utils/sort-nodes.mjs";
+import { makeFixes } from "../utils/make-fixes.mjs";
+import { complete } from "../utils/complete.mjs";
+import { pairwise } from "../utils/pairwise.mjs";
+import { compare } from "../utils/compare.mjs";
+const RULE_NAME = "sort-maps";
+const sortMaps = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted Map elements"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          type: {
+            enum: [
+              SortType.alphabetical,
+              SortType.natural,
+              SortType["line-length"]
+            ],
+            default: SortType.alphabetical,
+            type: "string"
+          },
+          order: {
+            enum: [SortOrder.asc, SortOrder.desc],
+            default: SortOrder.asc,
+            type: "string"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedMapElementsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    NewExpression: (node) => {
+      if (node.callee.type === "Identifier" && node.callee.name === "Map" && node.arguments.length && node.arguments[0].type === "ArrayExpression") {
+        let [{ elements }] = node.arguments;
+        if (elements.length > 1) {
+          let options = complete(context.options.at(0), {
+            type: SortType.alphabetical,
+            "ignore-case": false,
+            order: SortOrder.asc
+          });
+          let parts = elements.reduce(
+            (accumulator, element) => {
+              if (element === null || element.type === "SpreadElement") {
+                accumulator.push([]);
+              } else {
+                accumulator.at(-1).push(element);
+              }
+              return accumulator;
+            },
+            [[]]
+          );
+          for (let part of parts) {
+            let nodes = part.map((element) => {
+              let name;
+              if (element.type === "ArrayExpression") {
+                let [left] = element.elements;
+                if (!left) {
+                  name = `${left}`;
+                } else if (left.type === "Literal") {
+                  name = left.raw;
+                } else {
+                  name = context.sourceCode.text.slice(...left.range);
+                }
+              } else {
+                name = context.sourceCode.text.slice(...element.range);
+              }
+              return {
+                size: rangeToDiff(element.range),
+                node: element,
+                name
+              };
+            });
+            pairwise(nodes, (left, right) => {
+              if (isPositive(compare(left, right, options))) {
+                context.report({
+                  messageId: "unexpectedMapElementsOrder",
+                  data: {
+                    left: toSingleLine(left.name),
+                    right: toSingleLine(right.name)
+                  },
+                  node: right.node,
+                  fix: (fixer) => makeFixes(
+                    fixer,
+                    nodes,
+                    sortNodes(nodes, options),
+                    context.sourceCode
+                  )
+                });
+              }
+            });
+          }
+        }
+      }
+    }
+  })
+});
+export {
+  RULE_NAME,
+  sortMaps as default
+};

package/dist/rules/sort-named-exports.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const createEslintRule = require("../utils/create-eslint-rule.js");
+const index = require("../typings/index.js");
+const getGroupNumber = require("../utils/get-group-number.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 RULE_NAME = "sort-named-exports";
+const sortNamedExports = createEslintRule.createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted named exports"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          type: {
+            enum: [
+              index.SortType.alphabetical,
+              index.SortType.natural,
+              index.SortType["line-length"]
+            ],
+            default: index.SortType.alphabetical,
+            type: "string"
+          },
+          order: {
+            enum: [index.SortOrder.asc, index.SortOrder.desc],
+            default: index.SortOrder.asc,
+            type: "string"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          },
+          "group-kind": {
+            enum: [
+              index.GroupKind.mixed,
+              index.GroupKind["values-first"],
+              index.GroupKind["types-first"]
+            ],
+            default: index.GroupKind.mixed,
+            type: "string"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedNamedExportsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    ExportNamedDeclaration: (node) => {
+      if (node.specifiers.length > 1) {
+        let options = complete.complete(context.options.at(0), {
+          type: index.SortType.alphabetical,
+          "ignore-case": false,
+          order: index.SortOrder.asc,
+          "group-kind": index.GroupKind.mixed
+        });
+        let nodes = node.specifiers.map((specifier) => ({
+          size: rangeToDiff.rangeToDiff(specifier.range),
+          name: specifier.local.name,
+          node: specifier,
+          group: specifier.exportKind
+        }));
+        let shouldGroupByKind = options["group-kind"] !== index.GroupKind.mixed;
+        let groupKindOrder = options["group-kind"] === index.GroupKind["values-first"] ? ["value", "type"] : ["type", "value"];
+        pairwise.pairwise(nodes, (left, right) => {
+          let leftNum = getGroupNumber.getGroupNumber(groupKindOrder, left);
+          let rightNum = getGroupNumber.getGroupNumber(groupKindOrder, right);
+          if (shouldGroupByKind && leftNum > rightNum || (!shouldGroupByKind || leftNum === rightNum) && isPositive.isPositive(compare.compare(left, right, options))) {
+            let sortedNodes = shouldGroupByKind ? groupKindOrder.map((group) => nodes.filter((n) => n.group === group)).map((groupedNodes) => sortNodes.sortNodes(groupedNodes, options)).flat() : sortNodes.sortNodes(nodes, options);
+            context.report({
+              messageId: "unexpectedNamedExportsOrder",
+              data: {
+                left: left.name,
+                right: right.name
+              },
+              node: right.node,
+              fix: (fixer) => makeFixes.makeFixes(fixer, nodes, sortedNodes, context.sourceCode)
+            });
+          }
+        });
+      }
+    }
+  })
+});
+exports.RULE_NAME = RULE_NAME;
+exports.default = sortNamedExports;

package/dist/rules/sort-named-exports.mjs

@@ -0,0 +1,105 @@
+import { createEslintRule } from "../utils/create-eslint-rule.mjs";
+import { SortType, SortOrder, GroupKind } from "../typings/index.mjs";
+import { getGroupNumber } from "../utils/get-group-number.mjs";
+import { rangeToDiff } from "../utils/range-to-diff.mjs";
+import { isPositive } from "../utils/is-positive.mjs";
+import { sortNodes } from "../utils/sort-nodes.mjs";
+import { makeFixes } from "../utils/make-fixes.mjs";
+import { complete } from "../utils/complete.mjs";
+import { pairwise } from "../utils/pairwise.mjs";
+import { compare } from "../utils/compare.mjs";
+const RULE_NAME = "sort-named-exports";
+const sortNamedExports = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted named exports"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          type: {
+            enum: [
+              SortType.alphabetical,
+              SortType.natural,
+              SortType["line-length"]
+            ],
+            default: SortType.alphabetical,
+            type: "string"
+          },
+          order: {
+            enum: [SortOrder.asc, SortOrder.desc],
+            default: SortOrder.asc,
+            type: "string"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          },
+          "group-kind": {
+            enum: [
+              GroupKind.mixed,
+              GroupKind["values-first"],
+              GroupKind["types-first"]
+            ],
+            default: GroupKind.mixed,
+            type: "string"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedNamedExportsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    ExportNamedDeclaration: (node) => {
+      if (node.specifiers.length > 1) {
+        let options = complete(context.options.at(0), {
+          type: SortType.alphabetical,
+          "ignore-case": false,
+          order: SortOrder.asc,
+          "group-kind": GroupKind.mixed
+        });
+        let nodes = node.specifiers.map((specifier) => ({
+          size: rangeToDiff(specifier.range),
+          name: specifier.local.name,
+          node: specifier,
+          group: specifier.exportKind
+        }));
+        let shouldGroupByKind = options["group-kind"] !== GroupKind.mixed;
+        let groupKindOrder = options["group-kind"] === GroupKind["values-first"] ? ["value", "type"] : ["type", "value"];
+        pairwise(nodes, (left, right) => {
+          let leftNum = getGroupNumber(groupKindOrder, left);
+          let rightNum = getGroupNumber(groupKindOrder, right);
+          if (shouldGroupByKind && leftNum > rightNum || (!shouldGroupByKind || leftNum === rightNum) && isPositive(compare(left, right, options))) {
+            let sortedNodes = shouldGroupByKind ? groupKindOrder.map((group) => nodes.filter((n) => n.group === group)).map((groupedNodes) => sortNodes(groupedNodes, options)).flat() : sortNodes(nodes, options);
+            context.report({
+              messageId: "unexpectedNamedExportsOrder",
+              data: {
+                left: left.name,
+                right: right.name
+              },
+              node: right.node,
+              fix: (fixer) => makeFixes(fixer, nodes, sortedNodes, context.sourceCode)
+            });
+          }
+        });
+      }
+    }
+  })
+});
+export {
+  RULE_NAME,
+  sortNamedExports as default
+};