@saasmakers/eslint 1.0.4 → 1.0.6

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { d as distExports } from './shared/eslint.CohBuu1-.mjs';
 import 'eslint';
 import 'eslint/use-at-your-own-risk';
 
-const rule$b = {
+const rule$c = {
   meta: {
     docs: {
       description: "Enforce one-line ternaries if under a character limit, multiline otherwise",
@@ -64,7 +64,7 @@ const rule$b = {
   }
 };
 
-const rule$a = {
+const rule$b = {
   meta: {
     docs: {
       description: "Enforce multiline formatting for union types with more than N items",
@@ -134,6 +134,166 @@ const rule$a = {
   }
 };
 
+function collapseBlankLine(text) {
+  return text.replace(/\n[^\S\n]*\n[^\S\n]*/, "\n");
+}
+function getActualLastToken(node, sourceCode) {
+  const semiToken = sourceCode.getLastToken(node);
+  if (!semiToken) {
+    return null;
+  }
+  const prevToken = sourceCode.getTokenBefore(semiToken);
+  const nextToken = sourceCode.getTokenAfter(semiToken);
+  if (prevToken && nextToken && prevToken.range[0] >= node.range[0] && semiToken.type === "Punctuator" && semiToken.value === ";" && prevToken.loc.end.line < semiToken.loc.start.line && semiToken.loc.end.line === nextToken.loc.start.line) {
+    return prevToken;
+  }
+  return semiToken;
+}
+function getBlankLineRequirement(prevNode, nextNode) {
+  if (!isAwaitStatement(prevNode)) {
+    return null;
+  }
+  if (!isAwaitStatement(nextNode)) {
+    return "always";
+  }
+  if (isSingleLine(prevNode) && isSingleLine(nextNode)) {
+    return "never";
+  }
+  return "always";
+}
+function getPaddingLineSequences(prevNode, nextNode, sourceCode) {
+  const pairs = [];
+  const prevToken = getActualLastToken(prevNode, sourceCode);
+  if (!prevToken) {
+    return pairs;
+  }
+  if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {
+    let currentToken = prevToken;
+    while (currentToken.range[0] < nextNode.range[0]) {
+      const token = sourceCode.getTokenAfter(currentToken, { includeComments: true });
+      if (!token || token.range[0] >= nextNode.range[0]) {
+        break;
+      }
+      if (token.loc.start.line - currentToken.loc.end.line >= 2) {
+        pairs.push([currentToken, token]);
+      }
+      currentToken = token;
+    }
+  }
+  return pairs;
+}
+function isAwaitStatement(node) {
+  return node.type === distExports.AST_NODE_TYPES.ExpressionStatement && node.expression.type === distExports.AST_NODE_TYPES.AwaitExpression;
+}
+function isSingleLine(node) {
+  return node.loc.start.line === node.loc.end.line;
+}
+const rule$a = {
+  defaultOptions: [],
+  meta: {
+    docs: { description: "Require or disallow padding lines between standalone await statements" },
+    fixable: "whitespace",
+    messages: {
+      expectedBlankLine: "Expected blank line before this statement.",
+      unexpectedBlankLine: "Unexpected blank line before this statement."
+    },
+    schema: [],
+    type: "layout"
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    let scopeInfo = null;
+    function enterScope() {
+      scopeInfo = {
+        prevNode: null,
+        upper: scopeInfo
+      };
+    }
+    function exitScope() {
+      if (scopeInfo) {
+        scopeInfo = scopeInfo.upper;
+      }
+    }
+    function verify(node) {
+      const parentType = node.parent?.type;
+      const allowedParents = /* @__PURE__ */ new Set([
+        distExports.AST_NODE_TYPES.BlockStatement,
+        distExports.AST_NODE_TYPES.Program,
+        distExports.AST_NODE_TYPES.StaticBlock,
+        distExports.AST_NODE_TYPES.SwitchCase
+      ]);
+      if (!parentType || !allowedParents.has(parentType)) {
+        return;
+      }
+      const prevNode = scopeInfo?.prevNode;
+      if (prevNode) {
+        const requirement = getBlankLineRequirement(prevNode, node);
+        if (requirement) {
+          const paddingLines = getPaddingLineSequences(prevNode, node, sourceCode);
+          if (requirement === "never" && paddingLines.length > 0) {
+            context.report({
+              fix(fixer) {
+                if (paddingLines.length >= 2) {
+                  return null;
+                }
+                const [prevToken, nextToken] = paddingLines[0];
+                const start = prevToken.range[1];
+                const end = nextToken.range[0];
+                const text = collapseBlankLine(sourceCode.text.slice(start, end));
+                return fixer.replaceTextRange([start, end], text);
+              },
+              messageId: "unexpectedBlankLine",
+              node
+            });
+          } else if (requirement === "always" && paddingLines.length === 0) {
+            context.report({
+              fix(fixer) {
+                const lastToken = getActualLastToken(prevNode, sourceCode);
+                if (!lastToken) {
+                  return null;
+                }
+                let currentPrevToken = lastToken;
+                const nextToken = sourceCode.getFirstTokenBetween(currentPrevToken, node, {
+                  filter(token) {
+                    if (token.loc.start.line === currentPrevToken.loc.start.line) {
+                      currentPrevToken = token;
+                      return false;
+                    }
+                    return true;
+                  },
+                  includeComments: true
+                }) || node;
+                const insertText = currentPrevToken.loc.end.line === nextToken.loc.start.line ? "\n\n" : "\n";
+                return fixer.insertTextAfter(currentPrevToken, insertText);
+              },
+              messageId: "expectedBlankLine",
+              node
+            });
+          }
+        }
+      }
+      if (scopeInfo) {
+        scopeInfo.prevNode = node;
+      }
+    }
+    function verifyThenEnterScope(node) {
+      verify(node);
+      enterScope();
+    }
+    return {
+      ":statement": verify,
+      "BlockStatement": enterScope,
+      "BlockStatement:exit": exitScope,
+      "Program": enterScope,
+      "Program:exit": exitScope,
+      "StaticBlock": enterScope,
+      "StaticBlock:exit": exitScope,
+      "SwitchCase": verifyThenEnterScope,
+      "SwitchCase:exit": exitScope
+    };
+  }
+};
+
 function compareTests(testA, testB) {
   const functionA = getFunctionName(testA);
   const functionB = getFunctionName(testB);
@@ -860,8 +1020,9 @@ const rule = {
 
 const index = {
   rules: {
-    "ts-multiline-ternary": rule$b,
-    "ts-multiline-union": rule$a,
+    "ts-multiline-ternary": rule$c,
+    "ts-multiline-union": rule$b,
+    "ts-padding-await-statements": rule$a,
     "ts-sort-tests": rule$9,
     "vue-i18n-consistent-locales": rule$8,
     "vue-i18n-consistent-t": rule$7,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saasmakers/eslint",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "private": false,
   "description": "Shared ESLint config and rules for SaaS Makers projects",
   "license": "MIT",
@@ -27,17 +27,16 @@
   ],
   "dependencies": {
     "@antfu/eslint-config": "7.4.3",
-    "@unocss/eslint-plugin": "66.6.0",
-    "@vitest/eslint-plugin": "1.6.9",
+    "@unocss/eslint-plugin": "66.7.0",
+    "@vitest/eslint-plugin": "1.6.20",
     "eslint-plugin-package-json": "0.31.0",
-    "eslint-plugin-storybook": "10.2.8",
-    "eslint-plugin-turbo": "2.8.10",
+    "eslint-plugin-turbo": "2.9.18",
     "eslint-plugin-zod": "3.4.0",
-    "typescript-eslint": "8.55.0"
+    "typescript-eslint": "8.61.0"
   },
   "devDependencies": {
     "@eslint/config-inspector": "1.4.2",
-    "eslint": "10.0.1",
+    "eslint": "10.4.1",
     "typescript": "5.9.3"
   },
   "peerDependencies": {