eslint-plugin-perfectionist 2.7.0 → 2.9.0

package/dist/rules/sort-interfaces.mjs

@@ -0,0 +1,253 @@
+import { minimatch } from "minimatch";
+import { OptionalityOrder, SortType, SortOrder } from "../typings/index.mjs";
+import { createEslintRule } from "../utils/create-eslint-rule.mjs";
+import { isMemberOptional } from "../utils/is-member-optional.mjs";
+import { getLinesBetween } from "../utils/get-lines-between.mjs";
+import { getGroupNumber } from "../utils/get-group-number.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 { useGroups } from "../utils/use-groups.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-interfaces";
+const sortInterfaces = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted interface properties"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          "custom-groups": {
+            type: "object"
+          },
+          "optionality-order": {
+            enum: [
+              OptionalityOrder.ignore,
+              OptionalityOrder["optional-first"],
+              OptionalityOrder["required-first"]
+            ],
+            default: OptionalityOrder.ignore,
+            type: "string"
+          },
+          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
+          },
+          "ignore-pattern": {
+            items: {
+              type: "string"
+            },
+            type: "array"
+          },
+          groups: {
+            type: "array",
+            default: []
+          },
+          "partition-by-new-line": {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedInterfacePropertiesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    TSInterfaceDeclaration: (node) => {
+      if (node.body.body.length > 1) {
+        let options = complete(context.options.at(0), {
+          "optionality-order": OptionalityOrder.ignore,
+          "partition-by-new-line": false,
+          type: SortType.alphabetical,
+          "ignore-case": false,
+          order: SortOrder.asc,
+          "ignore-pattern": [],
+          "custom-groups": {},
+          groups: []
+        });
+        if (!options["ignore-pattern"].some(
+          (pattern) => minimatch(node.id.name, pattern, {
+            nocomment: true
+          })
+        )) {
+          let formattedMembers = node.body.body.reduce(
+            (accumulator, element) => {
+              var _a, _b, _c, _d;
+              if (element.type === "TSCallSignatureDeclaration") {
+                accumulator.push([]);
+                return accumulator;
+              }
+              let lastElement = (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1);
+              let name;
+              let { getGroup, defineGroup, setCustomGroups } = useGroups(
+                options.groups
+              );
+              if (element.type === "TSPropertySignature") {
+                if (element.key.type === "Identifier") {
+                  ({ name } = element.key);
+                } else if (element.key.type === "Literal") {
+                  name = `${element.key.value}`;
+                } else {
+                  let end = ((_b = element.typeAnnotation) == null ? void 0 : _b.range.at(0)) ?? element.range.at(1) - (element.optional ? "?".length : 0);
+                  name = context.sourceCode.text.slice(element.range.at(0), end);
+                }
+              } else if (element.type === "TSIndexSignature") {
+                let endIndex = ((_c = element.typeAnnotation) == null ? void 0 : _c.range.at(0)) ?? element.range.at(1);
+                name = context.sourceCode.text.slice(
+                  element.range.at(0),
+                  endIndex
+                );
+              } else {
+                let endIndex = ((_d = element.returnType) == null ? void 0 : _d.range.at(0)) ?? element.range.at(1);
+                name = context.sourceCode.text.slice(
+                  element.range.at(0),
+                  endIndex
+                );
+              }
+              let elementSortingNode = {
+                size: rangeToDiff(element.range),
+                node: element,
+                name
+              };
+              if (options["partition-by-new-line"] && lastElement && getLinesBetween(
+                context.sourceCode,
+                lastElement,
+                elementSortingNode
+              )) {
+                accumulator.push([]);
+              }
+              setCustomGroups(options["custom-groups"], name);
+              if (element.loc.start.line !== element.loc.end.line) {
+                defineGroup("multiline");
+              }
+              accumulator.at(-1).push({
+                ...elementSortingNode,
+                group: getGroup()
+              });
+              return accumulator;
+            },
+            [[]]
+          );
+          let toSorted = (nodes) => {
+            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 sortedNodes;
+          };
+          let checkGroupSort = (left, right) => {
+            let leftNum = getGroupNumber(options.groups, left);
+            let rightNum = getGroupNumber(options.groups, right);
+            return leftNum > rightNum || leftNum === rightNum && isPositive(compare(left, right, options));
+          };
+          let optionalityOrder = options["optionality-order"];
+          let checkOrder = (members, left, right, iteration) => {
+            if (optionalityOrder === OptionalityOrder.ignore) {
+              return checkGroupSort(left, right);
+            }
+            let switchIndex = members.findIndex(
+              (_, i) => i && isMemberOptional(members[i - 1].node) !== isMemberOptional(members[i].node)
+            );
+            if (iteration < switchIndex && iteration + 1 !== switchIndex) {
+              return checkGroupSort(left, right);
+            }
+            if (isMemberOptional(left.node) !== isMemberOptional(right.node)) {
+              return isMemberOptional(left.node) !== (optionalityOrder === OptionalityOrder["optional-first"]);
+            }
+            return checkGroupSort(left, right);
+          };
+          for (let nodes of formattedMembers) {
+            pairwise(nodes, (left, right, iteration) => {
+              if (checkOrder(nodes, left, right, iteration)) {
+                context.report({
+                  messageId: "unexpectedInterfacePropertiesOrder",
+                  data: {
+                    left: toSingleLine(left.name),
+                    right: toSingleLine(right.name)
+                  },
+                  node: right.node,
+                  fix: (fixer) => {
+                    let sortedNodes;
+                    if (optionalityOrder !== OptionalityOrder.ignore) {
+                      let optionalNodes = nodes.filter(
+                        (member) => isMemberOptional(member.node)
+                      );
+                      let requiredNodes = nodes.filter(
+                        (member) => !isMemberOptional(member.node)
+                      );
+                      sortedNodes = optionalityOrder === OptionalityOrder["optional-first"] ? [
+                        ...toSorted(optionalNodes),
+                        ...toSorted(requiredNodes)
+                      ] : [
+                        ...toSorted(requiredNodes),
+                        ...toSorted(optionalNodes)
+                      ];
+                    } else {
+                      sortedNodes = toSorted(nodes);
+                    }
+                    return makeFixes(
+                      fixer,
+                      nodes,
+                      sortedNodes,
+                      context.sourceCode
+                    );
+                  }
+                });
+              }
+            });
+          }
+        }
+      }
+    }
+  })
+});
+export {
+  RULE_NAME,
+  sortInterfaces as default
+};

package/dist/rules/sort-intersection-types.js

@@ -0,0 +1,92 @@
+"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-intersection-types";
+const sortIntersectionTypes = createEslintRule.createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted intersection types"
+    },
+    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: {
+      unexpectedIntersectionTypesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    TSIntersectionType: (node) => {
+      let options = complete.complete(context.options.at(0), {
+        type: index.SortType.alphabetical,
+        "ignore-case": false,
+        order: index.SortOrder.asc
+      });
+      let nodes = node.types.map((type) => ({
+        group: type.type === "TSNullKeyword" || type.type === "TSUndefinedKeyword" ? "nullable" : "unknown",
+        name: context.sourceCode.text.slice(...type.range),
+        size: rangeToDiff.rangeToDiff(type.range),
+        node: type
+      }));
+      pairwise.pairwise(nodes, (left, right) => {
+        let compareValue = isPositive.isPositive(compare.compare(left, right, options));
+        if (compareValue) {
+          context.report({
+            messageId: "unexpectedIntersectionTypesOrder",
+            data: {
+              left: toSingleLine.toSingleLine(left.name),
+              right: toSingleLine.toSingleLine(right.name)
+            },
+            node: right.node,
+            fix: (fixer) => {
+              let sortedNodes = sortNodes.sortNodes(nodes, options);
+              return makeFixes.makeFixes(fixer, nodes, sortedNodes, context.sourceCode);
+            }
+          });
+        }
+      });
+    }
+  })
+});
+exports.RULE_NAME = RULE_NAME;
+exports.default = sortIntersectionTypes;

package/dist/rules/sort-intersection-types.mjs

@@ -0,0 +1,92 @@
+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-intersection-types";
+const sortIntersectionTypes = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted intersection types"
+    },
+    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: {
+      unexpectedIntersectionTypesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    TSIntersectionType: (node) => {
+      let options = complete(context.options.at(0), {
+        type: SortType.alphabetical,
+        "ignore-case": false,
+        order: SortOrder.asc
+      });
+      let nodes = node.types.map((type) => ({
+        group: type.type === "TSNullKeyword" || type.type === "TSUndefinedKeyword" ? "nullable" : "unknown",
+        name: context.sourceCode.text.slice(...type.range),
+        size: rangeToDiff(type.range),
+        node: type
+      }));
+      pairwise(nodes, (left, right) => {
+        let compareValue = isPositive(compare(left, right, options));
+        if (compareValue) {
+          context.report({
+            messageId: "unexpectedIntersectionTypesOrder",
+            data: {
+              left: toSingleLine(left.name),
+              right: toSingleLine(right.name)
+            },
+            node: right.node,
+            fix: (fixer) => {
+              let sortedNodes = sortNodes(nodes, options);
+              return makeFixes(fixer, nodes, sortedNodes, context.sourceCode);
+            }
+          });
+        }
+      });
+    }
+  })
+});
+export {
+  RULE_NAME,
+  sortIntersectionTypes as default
+};

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const path = require("node:path");
+const createEslintRule = require("../utils/create-eslint-rule.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 index = require("../typings/index.js");
+const useGroups = require("../utils/use-groups.js");
+const makeFixes = require("../utils/make-fixes.js");
+const sortNodes = require("../utils/sort-nodes.js");
+const pairwise = require("../utils/pairwise.js");
+const complete = require("../utils/complete.js");
+const compare = require("../utils/compare.js");
+const RULE_NAME = "sort-jsx-props";
+const sortJsxProps = createEslintRule.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: [
+              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"
+          },
+          groups: {
+            type: "array"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedJSXPropsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.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.complete(context.options.at(0), {
+            type: index.SortType.alphabetical,
+            "ignore-case": false,
+            order: index.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.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.rangeToDiff(attribute.range),
+                group: getGroup(),
+                node: attribute,
+                name
+              };
+              accumulator.at(-1).push(jsxNode);
+              return accumulator;
+            },
+            [[]]
+          );
+          for (let nodes of parts) {
+            pairwise.pairwise(nodes, (left, right) => {
+              let leftNum = getGroupNumber.getGroupNumber(options.groups, left);
+              let rightNum = getGroupNumber.getGroupNumber(options.groups, right);
+              if (leftNum > rightNum || leftNum === rightNum && isPositive.isPositive(compare.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.getGroupNumber(options.groups, currentNode);
+                      if (!(groupNum in grouped)) {
+                        grouped[groupNum] = [currentNode];
+                      } else {
+                        grouped[groupNum] = sortNodes.sortNodes(
+                          [...grouped[groupNum], currentNode],
+                          options
+                        );
+                      }
+                    }
+                    let sortedNodes = [];
+                    for (let group of Object.keys(grouped).sort(
+                      (a, b) => Number(a) - Number(b)
+                    )) {
+                      sortedNodes.push(...sortNodes.sortNodes(grouped[group], options));
+                    }
+                    return makeFixes.makeFixes(
+                      fixer,
+                      nodes,
+                      sortedNodes,
+                      context.sourceCode
+                    );
+                  }
+                });
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+exports.RULE_NAME = RULE_NAME;
+exports.default = sortJsxProps;