eslint-plugin-perfectionist 2.7.0 → 2.9.0

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

@@ -0,0 +1,123 @@
+"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-imports";
+const sortNamedImports = createEslintRule.createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted named imports"
+    },
+    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
+          },
+          "ignore-alias": {
+            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: {
+      unexpectedNamedImportsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    ImportDeclaration: (node) => {
+      let specifiers = node.specifiers.filter(
+        ({ type }) => type === "ImportSpecifier"
+      );
+      if (specifiers.length > 1) {
+        let options = complete.complete(context.options.at(0), {
+          type: index.SortType.alphabetical,
+          "ignore-alias": true,
+          "ignore-case": false,
+          order: index.SortOrder.asc,
+          "group-kind": index.GroupKind.mixed
+        });
+        let nodes = specifiers.map((specifier) => {
+          let group;
+          let { name } = specifier.local;
+          if (specifier.type === "ImportSpecifier") {
+            if (options["ignore-alias"]) {
+              ({ name } = specifier.imported);
+            }
+            group = specifier.importKind;
+          }
+          return {
+            size: rangeToDiff.rangeToDiff(specifier.range),
+            node: specifier,
+            name,
+            group
+          };
+        });
+        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: "unexpectedNamedImportsOrder",
+              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 = sortNamedImports;

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

@@ -0,0 +1,123 @@
+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-imports";
+const sortNamedImports = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted named imports"
+    },
+    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
+          },
+          "ignore-alias": {
+            type: "boolean",
+            default: false
+          },
+          "group-kind": {
+            enum: [
+              GroupKind.mixed,
+              GroupKind["values-first"],
+              GroupKind["types-first"]
+            ],
+            default: GroupKind.mixed,
+            type: "string"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedNamedImportsOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    ImportDeclaration: (node) => {
+      let specifiers = node.specifiers.filter(
+        ({ type }) => type === "ImportSpecifier"
+      );
+      if (specifiers.length > 1) {
+        let options = complete(context.options.at(0), {
+          type: SortType.alphabetical,
+          "ignore-alias": true,
+          "ignore-case": false,
+          order: SortOrder.asc,
+          "group-kind": GroupKind.mixed
+        });
+        let nodes = specifiers.map((specifier) => {
+          let group;
+          let { name } = specifier.local;
+          if (specifier.type === "ImportSpecifier") {
+            if (options["ignore-alias"]) {
+              ({ name } = specifier.imported);
+            }
+            group = specifier.importKind;
+          }
+          return {
+            size: rangeToDiff(specifier.range),
+            node: specifier,
+            name,
+            group
+          };
+        });
+        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: "unexpectedNamedImportsOrder",
+              data: {
+                left: left.name,
+                right: right.name
+              },
+              node: right.node,
+              fix: (fixer) => makeFixes(fixer, nodes, sortedNodes, context.sourceCode)
+            });
+          }
+        });
+      }
+    }
+  })
+});
+export {
+  RULE_NAME,
+  sortNamedImports as default
+};

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

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const createEslintRule = require("../utils/create-eslint-rule.js");
+const getLinesBetween = require("../utils/get-lines-between.js");
+const getGroupNumber = require("../utils/get-group-number.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 useGroups = require("../utils/use-groups.js");
+const complete = require("../utils/complete.js");
+const pairwise = require("../utils/pairwise.js");
+const compare = require("../utils/compare.js");
+const RULE_NAME = "sort-object-types";
+const sortObjectTypes = createEslintRule.createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted object types"
+    },
+    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"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          },
+          groups: {
+            type: "array",
+            default: []
+          },
+          "partition-by-new-line": {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedObjectTypesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    TSTypeLiteral: (node) => {
+      if (node.members.length > 1) {
+        let options = complete.complete(context.options.at(0), {
+          "partition-by-new-line": false,
+          type: index.SortType.alphabetical,
+          "ignore-case": false,
+          order: index.SortOrder.asc,
+          "custom-groups": {},
+          groups: []
+        });
+        let formattedMembers = node.members.reduce(
+          (accumulator, member) => {
+            var _a, _b, _c, _d;
+            let name;
+            let raw = context.sourceCode.text.slice(
+              member.range.at(0),
+              member.range.at(1)
+            );
+            let lastMember = (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1);
+            let { getGroup, defineGroup, setCustomGroups } = useGroups.useGroups(
+              options.groups
+            );
+            let formatName = (value) => value.replace(/(,|;)$/, "");
+            if (member.type === "TSPropertySignature") {
+              if (member.key.type === "Identifier") {
+                ({ name } = member.key);
+              } else if (member.key.type === "Literal") {
+                name = `${member.key.value}`;
+              } else {
+                name = context.sourceCode.text.slice(
+                  member.range.at(0),
+                  (_b = member.typeAnnotation) == null ? void 0 : _b.range.at(0)
+                );
+              }
+            } else if (member.type === "TSIndexSignature") {
+              let endIndex = ((_c = member.typeAnnotation) == null ? void 0 : _c.range.at(0)) ?? member.range.at(1);
+              name = formatName(
+                context.sourceCode.text.slice(member.range.at(0), endIndex)
+              );
+            } else {
+              name = formatName(
+                context.sourceCode.text.slice(
+                  member.range.at(0),
+                  member.range.at(1)
+                )
+              );
+            }
+            setCustomGroups(options["custom-groups"], name);
+            if (member.loc.start.line !== member.loc.end.line) {
+              defineGroup("multiline");
+            }
+            let endsWithComma = raw.endsWith(";") || raw.endsWith(",");
+            let endSize = endsWithComma ? 1 : 0;
+            let memberSortingNode = {
+              size: rangeToDiff.rangeToDiff(member.range) - endSize,
+              node: member,
+              name
+            };
+            if (options["partition-by-new-line"] && lastMember && getLinesBetween.getLinesBetween(context.sourceCode, lastMember, memberSortingNode)) {
+              accumulator.push([]);
+            }
+            (_d = accumulator.at(-1)) == null ? void 0 : _d.push({
+              ...memberSortingNode,
+              group: getGroup()
+            });
+            return accumulator;
+          },
+          [[]]
+        );
+        for (let nodes of formattedMembers) {
+          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: "unexpectedObjectTypesOrder",
+                data: {
+                  left: toSingleLine.toSingleLine(left.name),
+                  right: toSingleLine.toSingleLine(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 = sortObjectTypes;

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

@@ -0,0 +1,189 @@
+import { createEslintRule } from "../utils/create-eslint-rule.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 { SortType, SortOrder } from "../typings/index.mjs";
+import { sortNodes } from "../utils/sort-nodes.mjs";
+import { makeFixes } from "../utils/make-fixes.mjs";
+import { useGroups } from "../utils/use-groups.mjs";
+import { complete } from "../utils/complete.mjs";
+import { pairwise } from "../utils/pairwise.mjs";
+import { compare } from "../utils/compare.mjs";
+const RULE_NAME = "sort-object-types";
+const sortObjectTypes = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted object types"
+    },
+    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"
+          },
+          "ignore-case": {
+            type: "boolean",
+            default: false
+          },
+          groups: {
+            type: "array",
+            default: []
+          },
+          "partition-by-new-line": {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedObjectTypesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  create: (context) => ({
+    TSTypeLiteral: (node) => {
+      if (node.members.length > 1) {
+        let options = complete(context.options.at(0), {
+          "partition-by-new-line": false,
+          type: SortType.alphabetical,
+          "ignore-case": false,
+          order: SortOrder.asc,
+          "custom-groups": {},
+          groups: []
+        });
+        let formattedMembers = node.members.reduce(
+          (accumulator, member) => {
+            var _a, _b, _c, _d;
+            let name;
+            let raw = context.sourceCode.text.slice(
+              member.range.at(0),
+              member.range.at(1)
+            );
+            let lastMember = (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1);
+            let { getGroup, defineGroup, setCustomGroups } = useGroups(
+              options.groups
+            );
+            let formatName = (value) => value.replace(/(,|;)$/, "");
+            if (member.type === "TSPropertySignature") {
+              if (member.key.type === "Identifier") {
+                ({ name } = member.key);
+              } else if (member.key.type === "Literal") {
+                name = `${member.key.value}`;
+              } else {
+                name = context.sourceCode.text.slice(
+                  member.range.at(0),
+                  (_b = member.typeAnnotation) == null ? void 0 : _b.range.at(0)
+                );
+              }
+            } else if (member.type === "TSIndexSignature") {
+              let endIndex = ((_c = member.typeAnnotation) == null ? void 0 : _c.range.at(0)) ?? member.range.at(1);
+              name = formatName(
+                context.sourceCode.text.slice(member.range.at(0), endIndex)
+              );
+            } else {
+              name = formatName(
+                context.sourceCode.text.slice(
+                  member.range.at(0),
+                  member.range.at(1)
+                )
+              );
+            }
+            setCustomGroups(options["custom-groups"], name);
+            if (member.loc.start.line !== member.loc.end.line) {
+              defineGroup("multiline");
+            }
+            let endsWithComma = raw.endsWith(";") || raw.endsWith(",");
+            let endSize = endsWithComma ? 1 : 0;
+            let memberSortingNode = {
+              size: rangeToDiff(member.range) - endSize,
+              node: member,
+              name
+            };
+            if (options["partition-by-new-line"] && lastMember && getLinesBetween(context.sourceCode, lastMember, memberSortingNode)) {
+              accumulator.push([]);
+            }
+            (_d = accumulator.at(-1)) == null ? void 0 : _d.push({
+              ...memberSortingNode,
+              group: getGroup()
+            });
+            return accumulator;
+          },
+          [[]]
+        );
+        for (let nodes of formattedMembers) {
+          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: "unexpectedObjectTypesOrder",
+                data: {
+                  left: toSingleLine(left.name),
+                  right: toSingleLine(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,
+  sortObjectTypes as default
+};