@saasmakers/eslint 0.1.1

package/dist/index.cjs

@@ -0,0 +1,138 @@
+'use strict';
+
+const rule = {
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Enforce sorted test functions grouped by method with sorted exceptions and middlewares",
+      recommended: true
+    },
+    fixable: "code",
+    messages: { sortError: "Test functions should be grouped by method with sorted exceptions and middlewares." },
+    schema: [],
+    type: "suggestion"
+  },
+  create(context) {
+    if (!context.filename.endsWith(".spec.ts")) {
+      return {};
+    }
+    function getTestName(node) {
+      if (node.arguments && node.arguments[0] && node.arguments[0].type === "Literal") {
+        return node.arguments[0].value;
+      }
+      return "";
+    }
+    function getTestPriority(testName) {
+      if (testName.includes(".middlewares.")) {
+        return 3;
+      }
+      if (testName.includes(".exceptions.")) {
+        return 2;
+      }
+      return 1;
+    }
+    function getFunctionName(testName) {
+      const parts = testName.split(".");
+      return parts.slice(0, 2).join(".");
+    }
+    function getSpecificName(testName) {
+      const parts = testName.split(".");
+      const specialIndex = parts.findIndex(
+        (part) => part === "exceptions" || part === "middlewares"
+      );
+      if (specialIndex === -1) {
+        return parts.slice(2).join(".");
+      }
+      return parts.slice(specialIndex + 1).join(".");
+    }
+    function compareTests(testA, testB) {
+      const functionA = getFunctionName(testA);
+      const functionB = getFunctionName(testB);
+      if (functionA !== functionB) {
+        return functionA.localeCompare(functionB);
+      }
+      const priorityA = getTestPriority(testA);
+      const priorityB = getTestPriority(testB);
+      if (priorityA !== priorityB) {
+        return priorityA - priorityB;
+      }
+      const specificNameA = getSpecificName(testA);
+      const specificNameB = getSpecificName(testB);
+      return specificNameA.localeCompare(specificNameB);
+    }
+    function handleTestGroup(node) {
+      const testGroup = node.arguments[0];
+      if (!testGroup || !node.arguments[1]) {
+        return;
+      }
+      const groupCallback = node.arguments[1];
+      if (groupCallback.type !== "FunctionExpression" && groupCallback.type !== "ArrowFunctionExpression") {
+        return;
+      }
+      const callbackBody = groupCallback.body;
+      if (callbackBody.type !== "BlockStatement" || !callbackBody.body) {
+        return;
+      }
+      const tests = callbackBody.body.filter((statement) => {
+        return statement.type === "ExpressionStatement" && statement.expression.type === "CallExpression" && statement.expression.callee.type === "Identifier" && (statement.expression.callee.name === "test" || statement.expression.callee.name === "it");
+      });
+      const testNames = tests.map((test) => getTestName(test.expression));
+      const sortedTestNames = [...testNames].sort(compareTests);
+      const isSorted = testNames.every(
+        (name, index) => name === sortedTestNames[index]
+      );
+      if (!isSorted) {
+        context.report({
+          fix(fixer) {
+            const testMap = new Map(
+              tests.map((test) => [getTestName(test.expression), test])
+            );
+            const sortedTests = sortedTestNames.map((name) => testMap.get(name));
+            const fixes = [];
+            for (let index = 0; index < tests.length; index++) {
+              const originalTest = tests[index];
+              const sortedTest = sortedTests[index];
+              if (originalTest !== sortedTest) {
+                fixes.push(fixer.replaceText(
+                  originalTest,
+                  context.sourceCode.getText(sortedTest)
+                ));
+              }
+            }
+            return fixes;
+          },
+          loc: node.loc ?? void 0,
+          messageId: "sortError",
+          node
+        });
+      }
+    }
+    return {
+      'CallExpression[callee.name="describe"]': handleTestGroup,
+      'CallExpression[callee.object.name="describe"][callee.property.name="concurrent"]': handleTestGroup,
+      'CallExpression[callee.object.name="test"][callee.property.name="group"]': handleTestGroup
+    };
+  }
+};
+
+const index = {
+  rules: {
+    // 'ts-multiline-ternary': tsMultilineTernary,
+    // 'ts-multiline-union': tsMultilineUnion,
+    "ts-sort-tests": rule
+    // 'vue-i18n-consistent-locales': vueI18nConsistentLocales,
+    // 'vue-i18n-consistent-t': vueI18nConsistentT,
+    // 'vue-i18n-sort-keys': vueI18nSortKeys,
+    // 'vue-i18n-unused-strings': vueI18nUnusedStrings,
+    // 'vue-script-format-computed': vueScriptFormatComputed,
+    // 'vue-script-format-emits': vueScriptFormatEmits,
+    // 'vue-script-format-props': vueScriptFormatProps,
+    // 'vue-script-order': vueScriptOrder,
+    // 'vue-template-format-classes': vueTemplateFormatClasses,
+    // 'vue-template-format-props': vueTemplateFormatProps,
+    // 'vue-template-remove-comments': vueTemplateRemoveComments,
+    // 'vue-template-remove-true-attributes': vueTemplateRemoveTrueAttributes,
+  }
+};
+
+module.exports = index;

package/dist/index.d.cts

@@ -0,0 +1,9 @@
+import * as eslint from 'eslint';
+
+declare const _default: {
+    rules: {
+        'ts-sort-tests': eslint.Rule.RuleModule;
+    };
+};
+
+export = _default;

package/dist/index.d.mts

@@ -0,0 +1,9 @@
+import * as eslint from 'eslint';
+
+declare const _default: {
+    rules: {
+        'ts-sort-tests': eslint.Rule.RuleModule;
+    };
+};
+
+export { _default as default };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import * as eslint from 'eslint';
+
+declare const _default: {
+    rules: {
+        'ts-sort-tests': eslint.Rule.RuleModule;
+    };
+};
+
+export = _default;

package/dist/index.mjs

@@ -0,0 +1,136 @@
+const rule = {
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Enforce sorted test functions grouped by method with sorted exceptions and middlewares",
+      recommended: true
+    },
+    fixable: "code",
+    messages: { sortError: "Test functions should be grouped by method with sorted exceptions and middlewares." },
+    schema: [],
+    type: "suggestion"
+  },
+  create(context) {
+    if (!context.filename.endsWith(".spec.ts")) {
+      return {};
+    }
+    function getTestName(node) {
+      if (node.arguments && node.arguments[0] && node.arguments[0].type === "Literal") {
+        return node.arguments[0].value;
+      }
+      return "";
+    }
+    function getTestPriority(testName) {
+      if (testName.includes(".middlewares.")) {
+        return 3;
+      }
+      if (testName.includes(".exceptions.")) {
+        return 2;
+      }
+      return 1;
+    }
+    function getFunctionName(testName) {
+      const parts = testName.split(".");
+      return parts.slice(0, 2).join(".");
+    }
+    function getSpecificName(testName) {
+      const parts = testName.split(".");
+      const specialIndex = parts.findIndex(
+        (part) => part === "exceptions" || part === "middlewares"
+      );
+      if (specialIndex === -1) {
+        return parts.slice(2).join(".");
+      }
+      return parts.slice(specialIndex + 1).join(".");
+    }
+    function compareTests(testA, testB) {
+      const functionA = getFunctionName(testA);
+      const functionB = getFunctionName(testB);
+      if (functionA !== functionB) {
+        return functionA.localeCompare(functionB);
+      }
+      const priorityA = getTestPriority(testA);
+      const priorityB = getTestPriority(testB);
+      if (priorityA !== priorityB) {
+        return priorityA - priorityB;
+      }
+      const specificNameA = getSpecificName(testA);
+      const specificNameB = getSpecificName(testB);
+      return specificNameA.localeCompare(specificNameB);
+    }
+    function handleTestGroup(node) {
+      const testGroup = node.arguments[0];
+      if (!testGroup || !node.arguments[1]) {
+        return;
+      }
+      const groupCallback = node.arguments[1];
+      if (groupCallback.type !== "FunctionExpression" && groupCallback.type !== "ArrowFunctionExpression") {
+        return;
+      }
+      const callbackBody = groupCallback.body;
+      if (callbackBody.type !== "BlockStatement" || !callbackBody.body) {
+        return;
+      }
+      const tests = callbackBody.body.filter((statement) => {
+        return statement.type === "ExpressionStatement" && statement.expression.type === "CallExpression" && statement.expression.callee.type === "Identifier" && (statement.expression.callee.name === "test" || statement.expression.callee.name === "it");
+      });
+      const testNames = tests.map((test) => getTestName(test.expression));
+      const sortedTestNames = [...testNames].sort(compareTests);
+      const isSorted = testNames.every(
+        (name, index) => name === sortedTestNames[index]
+      );
+      if (!isSorted) {
+        context.report({
+          fix(fixer) {
+            const testMap = new Map(
+              tests.map((test) => [getTestName(test.expression), test])
+            );
+            const sortedTests = sortedTestNames.map((name) => testMap.get(name));
+            const fixes = [];
+            for (let index = 0; index < tests.length; index++) {
+              const originalTest = tests[index];
+              const sortedTest = sortedTests[index];
+              if (originalTest !== sortedTest) {
+                fixes.push(fixer.replaceText(
+                  originalTest,
+                  context.sourceCode.getText(sortedTest)
+                ));
+              }
+            }
+            return fixes;
+          },
+          loc: node.loc ?? void 0,
+          messageId: "sortError",
+          node
+        });
+      }
+    }
+    return {
+      'CallExpression[callee.name="describe"]': handleTestGroup,
+      'CallExpression[callee.object.name="describe"][callee.property.name="concurrent"]': handleTestGroup,
+      'CallExpression[callee.object.name="test"][callee.property.name="group"]': handleTestGroup
+    };
+  }
+};
+
+const index = {
+  rules: {
+    // 'ts-multiline-ternary': tsMultilineTernary,
+    // 'ts-multiline-union': tsMultilineUnion,
+    "ts-sort-tests": rule
+    // 'vue-i18n-consistent-locales': vueI18nConsistentLocales,
+    // 'vue-i18n-consistent-t': vueI18nConsistentT,
+    // 'vue-i18n-sort-keys': vueI18nSortKeys,
+    // 'vue-i18n-unused-strings': vueI18nUnusedStrings,
+    // 'vue-script-format-computed': vueScriptFormatComputed,
+    // 'vue-script-format-emits': vueScriptFormatEmits,
+    // 'vue-script-format-props': vueScriptFormatProps,
+    // 'vue-script-order': vueScriptOrder,
+    // 'vue-template-format-classes': vueTemplateFormatClasses,
+    // 'vue-template-format-props': vueTemplateFormatProps,
+    // 'vue-template-remove-comments': vueTemplateRemoveComments,
+    // 'vue-template-remove-true-attributes': vueTemplateRemoveTrueAttributes,
+  }
+};
+
+export { index as default };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@saasmakers/eslint",
+  "type": "module",
+  "version": "0.1.1",
+  "private": false,
+  "description": "Shared ESLint config for SaaS Makers projects",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/saasmakers/saasmakers-turborepo.git",
+    "directory": "packages/eslint"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "dist/index.cjs",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "peerDependencies": {
+    "eslint": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/estree": "1.0.8",
+    "typescript": "5.9.3",
+    "@saasmakers/config": "0.1.19"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "lint": "eslint . --max-warnings=0",
+    "typecheck": "tsc --noEmit"
+  }
+}