eslint-plugin-perfectionist 2.8.0 → 2.9.0

package/dist/package.json.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const name = "eslint-plugin-perfectionist";
+exports.name = name;

package/dist/package.json.mjs

@@ -0,0 +1,4 @@
+const name = "eslint-plugin-perfectionist";
+export {
+  name
+};

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

@@ -0,0 +1,129 @@
+"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";
+const sortArrayIncludes = createEslintRule.createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted arrays before include method"
+    },
+    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
+          },
+          "spread-last": {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedArrayIncludesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.SortOrder.asc
+    }
+  ],
+  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();
+          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));
+            }
+            if (compareValue) {
+              context.report({
+                messageId: "unexpectedArrayIncludesOrder",
+                data: {
+                  left: toSingleLine.toSingleLine(left.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));
+                      }
+                    }
+                  }
+                  return makeFixes.makeFixes(
+                    fixer,
+                    nodes,
+                    sortedNodes,
+                    context.sourceCode
+                  );
+                }
+              });
+            }
+          });
+        }
+      }
+    }
+  })
+});
+exports.RULE_NAME = RULE_NAME;
+exports.default = sortArrayIncludes;

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

@@ -0,0 +1,129 @@
+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-array-includes";
+const sortArrayIncludes = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted arrays before include method"
+    },
+    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
+          },
+          "spread-last": {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedArrayIncludesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  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(context.options.at(0), {
+            type: SortType.alphabetical,
+            order: 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(element.range),
+                  type: element.type,
+                  node: element
+                });
+              }
+              return accumulator;
+            },
+            [[], []]
+          ).flat();
+          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(compare(left, right, options));
+            }
+            if (compareValue) {
+              context.report({
+                messageId: "unexpectedArrayIncludesOrder",
+                data: {
+                  left: toSingleLine(left.name),
+                  right: toSingleLine(right.name)
+                },
+                node: right.node,
+                fix: (fixer) => {
+                  let sortedNodes = 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));
+                      }
+                    }
+                  }
+                  return makeFixes(
+                    fixer,
+                    nodes,
+                    sortedNodes,
+                    context.sourceCode
+                  );
+                }
+              });
+            }
+          });
+        }
+      }
+    }
+  })
+});
+export {
+  RULE_NAME,
+  sortArrayIncludes as default
+};

package/dist/rules/sort-astro-attributes.js

@@ -0,0 +1,161 @@
+"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-astro-attributes";
+const sortAstroAttributes = createEslintRule.createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted Astro attributes"
+    },
+    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"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedAstroAttributesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: index.SortType.alphabetical,
+      order: index.SortOrder.asc
+    }
+  ],
+  // @ts-ignore
+  create: (context) => {
+    if (path.extname(context.filename) !== ".astro") {
+      return {};
+    }
+    return {
+      JSXElement: (node) => {
+        let { attributes } = node.openingElement;
+        if (attributes.length > 1) {
+          let options = complete.complete(context.options.at(0), {
+            type: index.SortType.alphabetical,
+            order: index.SortOrder.asc,
+            "ignore-case": false,
+            "custom-groups": {},
+            groups: []
+          });
+          let parts = attributes.reduce(
+            (accumulator, attribute) => {
+              if (attribute.type === "JSXSpreadAttribute") {
+                accumulator.push([]);
+                return accumulator;
+              }
+              let name = typeof attribute.name.name === "string" ? attribute.name.name : context.sourceCode.text.slice(...attribute.name.range);
+              let { getGroup, defineGroup, setCustomGroups } = useGroups.useGroups(
+                options.groups
+              );
+              setCustomGroups(options["custom-groups"], name);
+              if (attribute.type === "AstroShorthandAttribute") {
+                defineGroup("astro-shorthand");
+                defineGroup("shorthand");
+              }
+              if (attribute.value === null) {
+                defineGroup("shorthand");
+              }
+              if (attribute.loc.start.line !== attribute.loc.end.line) {
+                defineGroup("multiline");
+              }
+              accumulator.at(-1).push({
+                size: rangeToDiff.rangeToDiff(attribute.range),
+                node: attribute,
+                group: getGroup(),
+                name
+              });
+              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: "unexpectedAstroAttributesOrder",
+                  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 = sortAstroAttributes;

package/dist/rules/sort-astro-attributes.mjs

@@ -0,0 +1,161 @@
+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-astro-attributes";
+const sortAstroAttributes = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "enforce sorted Astro attributes"
+    },
+    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"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedAstroAttributesOrder: 'Expected "{{right}}" to come before "{{left}}"'
+    }
+  },
+  defaultOptions: [
+    {
+      type: SortType.alphabetical,
+      order: SortOrder.asc
+    }
+  ],
+  // @ts-ignore
+  create: (context) => {
+    if (path.extname(context.filename) !== ".astro") {
+      return {};
+    }
+    return {
+      JSXElement: (node) => {
+        let { attributes } = node.openingElement;
+        if (attributes.length > 1) {
+          let options = complete(context.options.at(0), {
+            type: SortType.alphabetical,
+            order: SortOrder.asc,
+            "ignore-case": false,
+            "custom-groups": {},
+            groups: []
+          });
+          let parts = attributes.reduce(
+            (accumulator, attribute) => {
+              if (attribute.type === "JSXSpreadAttribute") {
+                accumulator.push([]);
+                return accumulator;
+              }
+              let name = typeof attribute.name.name === "string" ? attribute.name.name : context.sourceCode.text.slice(...attribute.name.range);
+              let { getGroup, defineGroup, setCustomGroups } = useGroups(
+                options.groups
+              );
+              setCustomGroups(options["custom-groups"], name);
+              if (attribute.type === "AstroShorthandAttribute") {
+                defineGroup("astro-shorthand");
+                defineGroup("shorthand");
+              }
+              if (attribute.value === null) {
+                defineGroup("shorthand");
+              }
+              if (attribute.loc.start.line !== attribute.loc.end.line) {
+                defineGroup("multiline");
+              }
+              accumulator.at(-1).push({
+                size: rangeToDiff(attribute.range),
+                node: attribute,
+                group: getGroup(),
+                name
+              });
+              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: "unexpectedAstroAttributesOrder",
+                  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,
+  sortAstroAttributes as default
+};