eslint-plugin-perfectionist 2.7.0 → 2.9.0

package/dist/rules/sort-classes.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const createEslintRule = require("../utils/create-eslint-rule.js");
+const getGroupNumber = require("../utils/get-group-number.js");
+const getNodeRange = require("../utils/get-node-range.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 useGroups = require("../utils/use-groups.js");
+const sortNodes = require("../utils/sort-nodes.js");
+const complete = require("../utils/complete.js");
+const pairwise = require("../utils/pairwise.js");
+const compare = require("../utils/compare.js");
+const RULE_NAME = "sort-classes";
+const sortClasses = createEslintRule.createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted classes"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          type: {
+            enum: [
+              index.SortType.alphabetical,
+              index.SortType.natural,
+              index.SortType["line-length"]
+            ],
+            default: index.SortType.alphabetical,
+            type: "string"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          },
+          order: {
+            enum: [index.SortOrder.asc, index.SortOrder.desc],
+            default: index.SortOrder.asc,
+            type: "string"
+          },
+          groups: {
+            type: "array",
+            default: []
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    ClassBody: (node) => {
+      if (node.body.length > 1) {
+        let options = complete.complete(context.options.at(0), {
+          type: index.SortType.alphabetical,
+          order: index.SortOrder.asc,
+          "ignore-case": false,
+          groups: ["property", "constructor", "method", "unknown"]
+        });
+        let nodes = node.body.map((member) => {
+          var _a;
+          let name;
+          let { getGroup, defineGroup } = useGroups.useGroups(options.groups);
+          if (member.type === "StaticBlock") {
+            name = "static";
+          } else if (member.type === "TSIndexSignature") {
+            name = context.sourceCode.text.slice(
+              member.range.at(0),
+              ((_a = member.typeAnnotation) == null ? void 0 : _a.range.at(0)) ?? member.range.at(1)
+            );
+          } else {
+            if (member.key.type === "Identifier") {
+              ({ name } = member.key);
+            } else {
+              name = context.sourceCode.text.slice(...member.key.range);
+            }
+          }
+          let isPrivate = name.startsWith("_") || name.startsWith("#");
+          let decorated = "decorators" in member && member.decorators.length > 0;
+          if (member.type === "MethodDefinition") {
+            if (member.kind === "constructor") {
+              defineGroup("constructor");
+            }
+            let isPrivateMethod = member.accessibility === "private" || isPrivate;
+            let isStaticMethod = member.static;
+            if (decorated) {
+              if (member.kind === "get") {
+                defineGroup("decorated-get-method");
+              }
+              if (member.kind === "set") {
+                defineGroup("decorated-set-method");
+              }
+              defineGroup("decorated-method");
+            }
+            if (isPrivateMethod && isStaticMethod) {
+              defineGroup("static-private-method");
+            }
+            if (isPrivateMethod) {
+              defineGroup("private-method");
+            }
+            if (isStaticMethod) {
+              defineGroup("static-method");
+            }
+            if (member.kind === "get") {
+              defineGroup("get-method");
+            }
+            if (member.kind === "set") {
+              defineGroup("set-method");
+            }
+            defineGroup("method");
+          } else if (member.type === "TSIndexSignature") {
+            defineGroup("index-signature");
+          } else if (member.type === "AccessorProperty") {
+            if (decorated) {
+              if (member.accessibility === "private" || isPrivate) {
+                defineGroup("private-decorated-accessor-property");
+              }
+              defineGroup("decorated-accessor-property");
+            }
+          } else if (member.type === "PropertyDefinition") {
+            if (decorated) {
+              if (member.accessibility === "private" || isPrivate) {
+                defineGroup("private-decorated-property");
+              }
+              defineGroup("decorated-property");
+            }
+            if (member.accessibility === "private" || isPrivate) {
+              defineGroup("private-property");
+            }
+            if (member.static) {
+              defineGroup("static-property");
+            }
+            defineGroup("property");
+          }
+          return {
+            size: rangeToDiff.rangeToDiff(member.range),
+            group: getGroup(),
+            node: member,
+            name
+          };
+        });
+        pairwise.pairwise(nodes, (left, right) => {
+          let leftNum = getGroupNumber.getGroupNumber(options.groups, left);
+          let rightNum = getGroupNumber.getGroupNumber(options.groups, right);
+          if (left.name !== right.name && (leftNum > rightNum || leftNum === rightNum && isPositive.isPositive(compare.compare(left, right, options)))) {
+            context.report({
+              messageId: "unexpectedClassesOrder",
+              data: {
+                left: toSingleLine.toSingleLine(left.name),
+                right: toSingleLine.toSingleLine(right.name)
+              },
+              node: right.node,
+              fix: (fixer) => {
+                let fixes = [];
+                let grouped = nodes.reduce(
+                  (accumulator, sortingNode) => {
+                    let groupNum = getGroupNumber.getGroupNumber(options.groups, sortingNode);
+                    if (!(groupNum in accumulator)) {
+                      accumulator[groupNum] = [sortingNode];
+                    } else {
+                      accumulator[groupNum] = sortNodes.sortNodes(
+                        [...accumulator[groupNum], sortingNode],
+                        options
+                      );
+                    }
+                    return accumulator;
+                  },
+                  {}
+                );
+                let formatted = Object.keys(grouped).sort((a, b) => Number(a) - Number(b)).reduce(
+                  (accumulator, group) => [
+                    ...accumulator,
+                    ...grouped[group]
+                  ],
+                  []
+                );
+                for (let i = 0, max = formatted.length; i < max; i++) {
+                  fixes.push(
+                    fixer.replaceTextRange(
+                      getNodeRange.getNodeRange(nodes.at(i).node, context.sourceCode),
+                      context.sourceCode.text.slice(
+                        ...getNodeRange.getNodeRange(
+                          formatted.at(i).node,
+                          context.sourceCode
+                        )
+                      )
+                    )
+                  );
+                }
+                return fixes;
+              }
+            });
+          }
+        });
+      }
+    }
+  })
+});
+exports.RULE_NAME = RULE_NAME;
+exports.default = sortClasses;

package/dist/rules/sort-classes.mjs

@@ -0,0 +1,213 @@
+import { createEslintRule } from "../utils/create-eslint-rule.mjs";
+import { getGroupNumber } from "../utils/get-group-number.mjs";
+import { getNodeRange } from "../utils/get-node-range.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 { useGroups } from "../utils/use-groups.mjs";
+import { sortNodes } from "../utils/sort-nodes.mjs";
+import { complete } from "../utils/complete.mjs";
+import { pairwise } from "../utils/pairwise.mjs";
+import { compare } from "../utils/compare.mjs";
+const RULE_NAME = "sort-classes";
+const sortClasses = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted classes"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          type: {
+            enum: [
+              SortType.alphabetical,
+              SortType.natural,
+              SortType["line-length"]
+            ],
+            default: SortType.alphabetical,
+            type: "string"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          },
+          order: {
+            enum: [SortOrder.asc, SortOrder.desc],
+            default: SortOrder.asc,
+            type: "string"
+          },
+          groups: {
+            type: "array",
+            default: []
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    ClassBody: (node) => {
+      if (node.body.length > 1) {
+        let options = complete(context.options.at(0), {
+          type: SortType.alphabetical,
+          order: SortOrder.asc,
+          "ignore-case": false,
+          groups: ["property", "constructor", "method", "unknown"]
+        });
+        let nodes = node.body.map((member) => {
+          var _a;
+          let name;
+          let { getGroup, defineGroup } = useGroups(options.groups);
+          if (member.type === "StaticBlock") {
+            name = "static";
+          } else if (member.type === "TSIndexSignature") {
+            name = context.sourceCode.text.slice(
+              member.range.at(0),
+              ((_a = member.typeAnnotation) == null ? void 0 : _a.range.at(0)) ?? member.range.at(1)
+            );
+          } else {
+            if (member.key.type === "Identifier") {
+              ({ name } = member.key);
+            } else {
+              name = context.sourceCode.text.slice(...member.key.range);
+            }
+          }
+          let isPrivate = name.startsWith("_") || name.startsWith("#");
+          let decorated = "decorators" in member && member.decorators.length > 0;
+          if (member.type === "MethodDefinition") {
+            if (member.kind === "constructor") {
+              defineGroup("constructor");
+            }
+            let isPrivateMethod = member.accessibility === "private" || isPrivate;
+            let isStaticMethod = member.static;
+            if (decorated) {
+              if (member.kind === "get") {
+                defineGroup("decorated-get-method");
+              }
+              if (member.kind === "set") {
+                defineGroup("decorated-set-method");
+              }
+              defineGroup("decorated-method");
+            }
+            if (isPrivateMethod && isStaticMethod) {
+              defineGroup("static-private-method");
+            }
+            if (isPrivateMethod) {
+              defineGroup("private-method");
+            }
+            if (isStaticMethod) {
+              defineGroup("static-method");
+            }
+            if (member.kind === "get") {
+              defineGroup("get-method");
+            }
+            if (member.kind === "set") {
+              defineGroup("set-method");
+            }
+            defineGroup("method");
+          } else if (member.type === "TSIndexSignature") {
+            defineGroup("index-signature");
+          } else if (member.type === "AccessorProperty") {
+            if (decorated) {
+              if (member.accessibility === "private" || isPrivate) {
+                defineGroup("private-decorated-accessor-property");
+              }
+              defineGroup("decorated-accessor-property");
+            }
+          } else if (member.type === "PropertyDefinition") {
+            if (decorated) {
+              if (member.accessibility === "private" || isPrivate) {
+                defineGroup("private-decorated-property");
+              }
+              defineGroup("decorated-property");
+            }
+            if (member.accessibility === "private" || isPrivate) {
+              defineGroup("private-property");
+            }
+            if (member.static) {
+              defineGroup("static-property");
+            }
+            defineGroup("property");
+          }
+          return {
+            size: rangeToDiff(member.range),
+            group: getGroup(),
+            node: member,
+            name
+          };
+        });
+        pairwise(nodes, (left, right) => {
+          let leftNum = getGroupNumber(options.groups, left);
+          let rightNum = getGroupNumber(options.groups, right);
+          if (left.name !== right.name && (leftNum > rightNum || leftNum === rightNum && isPositive(compare(left, right, options)))) {
+            context.report({
+              messageId: "unexpectedClassesOrder",
+              data: {
+                left: toSingleLine(left.name),
+                right: toSingleLine(right.name)
+              },
+              node: right.node,
+              fix: (fixer) => {
+                let fixes = [];
+                let grouped = nodes.reduce(
+                  (accumulator, sortingNode) => {
+                    let groupNum = getGroupNumber(options.groups, sortingNode);
+                    if (!(groupNum in accumulator)) {
+                      accumulator[groupNum] = [sortingNode];
+                    } else {
+                      accumulator[groupNum] = sortNodes(
+                        [...accumulator[groupNum], sortingNode],
+                        options
+                      );
+                    }
+                    return accumulator;
+                  },
+                  {}
+                );
+                let formatted = Object.keys(grouped).sort((a, b) => Number(a) - Number(b)).reduce(
+                  (accumulator, group) => [
+                    ...accumulator,
+                    ...grouped[group]
+                  ],
+                  []
+                );
+                for (let i = 0, max = formatted.length; i < max; i++) {
+                  fixes.push(
+                    fixer.replaceTextRange(
+                      getNodeRange(nodes.at(i).node, context.sourceCode),
+                      context.sourceCode.text.slice(
+                        ...getNodeRange(
+                          formatted.at(i).node,
+                          context.sourceCode
+                        )
+                      )
+                    )
+                  );
+                }
+                return fixes;
+              }
+            });
+          }
+        });
+      }
+    }
+  })
+});
+export {
+  RULE_NAME,
+  sortClasses as default
+};

package/dist/rules/sort-enums.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const isPartitionComment = require("../utils/is-partition-comment.js");
+const createEslintRule = require("../utils/create-eslint-rule.js");
+const getCommentBefore = require("../utils/get-comment-before.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-enums";
+const sortEnums = createEslintRule.createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted TypeScript enums"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          "partition-by-comment": {
+            default: false,
+            type: ["boolean", "string", "array"]
+          },
+          type: {
+            enum: [
+              index.SortType.alphabetical,
+              index.SortType.natural,
+              index.SortType["line-length"]
+            ],
+            default: index.SortType.alphabetical,
+            type: "string"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          },
+          order: {
+            enum: [index.SortOrder.asc, index.SortOrder.desc],
+            default: index.SortOrder.asc,
+            type: "string"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedEnumsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    TSEnumDeclaration: (node) => {
+      if (node.members.length > 1 && node.members.every(({ initializer }) => initializer)) {
+        let options = complete.complete(context.options.at(0), {
+          type: index.SortType.alphabetical,
+          order: index.SortOrder.asc,
+          "ignore-case": false,
+          "partition-by-comment": false
+        });
+        let partitionComment = options["partition-by-comment"];
+        let formattedMembers = node.members.reduce(
+          (accumulator, member) => {
+            let comment = getCommentBefore.getCommentBefore(member, context.sourceCode);
+            if (partitionComment && comment && isPartitionComment.isPartitionComment(partitionComment, comment.value)) {
+              accumulator.push([]);
+            }
+            let name = member.id.type === "Literal" ? `${member.id.value}` : `${context.sourceCode.text.slice(...member.id.range)}`;
+            let sortingNode = {
+              name,
+              node: member,
+              size: rangeToDiff.rangeToDiff(member.range)
+            };
+            accumulator.at(-1).push(sortingNode);
+            return accumulator;
+          },
+          [[]]
+        );
+        for (let nodes of formattedMembers) {
+          pairwise.pairwise(nodes, (left, right) => {
+            if (isPositive.isPositive(compare.compare(left, right, options))) {
+              context.report({
+                messageId: "unexpectedEnumsOrder",
+                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,
+                  { partitionComment }
+                )
+              });
+            }
+          });
+        }
+      }
+    }
+  })
+});
+exports.RULE_NAME = RULE_NAME;
+exports.default = sortEnums;

package/dist/rules/sort-enums.mjs

@@ -0,0 +1,117 @@
+import { isPartitionComment } from "../utils/is-partition-comment.mjs";
+import { createEslintRule } from "../utils/create-eslint-rule.mjs";
+import { getCommentBefore } from "../utils/get-comment-before.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-enums";
+const sortEnums = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted TypeScript enums"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          "partition-by-comment": {
+            default: false,
+            type: ["boolean", "string", "array"]
+          },
+          type: {
+            enum: [
+              SortType.alphabetical,
+              SortType.natural,
+              SortType["line-length"]
+            ],
+            default: SortType.alphabetical,
+            type: "string"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          },
+          order: {
+            enum: [SortOrder.asc, SortOrder.desc],
+            default: SortOrder.asc,
+            type: "string"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedEnumsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    TSEnumDeclaration: (node) => {
+      if (node.members.length > 1 && node.members.every(({ initializer }) => initializer)) {
+        let options = complete(context.options.at(0), {
+          type: SortType.alphabetical,
+          order: SortOrder.asc,
+          "ignore-case": false,
+          "partition-by-comment": false
+        });
+        let partitionComment = options["partition-by-comment"];
+        let formattedMembers = node.members.reduce(
+          (accumulator, member) => {
+            let comment = getCommentBefore(member, context.sourceCode);
+            if (partitionComment && comment && isPartitionComment(partitionComment, comment.value)) {
+              accumulator.push([]);
+            }
+            let name = member.id.type === "Literal" ? `${member.id.value}` : `${context.sourceCode.text.slice(...member.id.range)}`;
+            let sortingNode = {
+              name,
+              node: member,
+              size: rangeToDiff(member.range)
+            };
+            accumulator.at(-1).push(sortingNode);
+            return accumulator;
+          },
+          [[]]
+        );
+        for (let nodes of formattedMembers) {
+          pairwise(nodes, (left, right) => {
+            if (isPositive(compare(left, right, options))) {
+              context.report({
+                messageId: "unexpectedEnumsOrder",
+                data: {
+                  left: toSingleLine(left.name),
+                  right: toSingleLine(right.name)
+                },
+                node: right.node,
+                fix: (fixer) => makeFixes(
+                  fixer,
+                  nodes,
+                  sortNodes(nodes, options),
+                  context.sourceCode,
+                  { partitionComment }
+                )
+              });
+            }
+          });
+        }
+      }
+    }
+  })
+});
+export {
+  RULE_NAME,
+  sortEnums as default
+};