@saasmakers/eslint 1.0.6 → 1.0.8

package/dist/eslint.config.cjs

@@ -10867,76 +10867,13 @@ const eslint_config = antfu__default(
   {
     plugins: { saasmakers: saasmakers__default },
     rules: {
-      "saasmakers/ts-padding-await-statements": "error",
+      "saasmakers/ts-padding-statements": "error",
       "saasmakers/ts-sort-tests": "error"
     }
   },
   // Stylistic
   {
     rules: {
-      "style/padding-line-between-statements": [
-        "error",
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-let",
-          prev: "multiline-let"
-        }
-      ],
       "style/object-property-newline": ["error", { allowAllPropertiesOnSameLine: false }],
       "style/object-curly-newline": ["error", {
         ExportDeclaration: {

package/dist/eslint.config.d.cts

@@ -147,76 +147,13 @@ var eslint_config = antfu(
   {
     plugins: { saasmakers },
     rules: {
-      "saasmakers/ts-padding-await-statements": "error",
+      "saasmakers/ts-padding-statements": "error",
       "saasmakers/ts-sort-tests": "error"
     }
   },
   // Stylistic
   {
     rules: {
-      "style/padding-line-between-statements": [
-        "error",
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-let",
-          prev: "multiline-let"
-        }
-      ],
       "style/object-property-newline": ["error", { allowAllPropertiesOnSameLine: false }],
       "style/object-curly-newline": ["error", {
         ExportDeclaration: {

package/dist/eslint.config.d.mts

@@ -147,76 +147,13 @@ var eslint_config = antfu(
   {
     plugins: { saasmakers },
     rules: {
-      "saasmakers/ts-padding-await-statements": "error",
+      "saasmakers/ts-padding-statements": "error",
       "saasmakers/ts-sort-tests": "error"
     }
   },
   // Stylistic
   {
     rules: {
-      "style/padding-line-between-statements": [
-        "error",
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-let",
-          prev: "multiline-let"
-        }
-      ],
       "style/object-property-newline": ["error", { allowAllPropertiesOnSameLine: false }],
       "style/object-curly-newline": ["error", {
         ExportDeclaration: {

package/dist/eslint.config.d.ts

@@ -147,76 +147,13 @@ var eslint_config = antfu(
   {
     plugins: { saasmakers },
     rules: {
-      "saasmakers/ts-padding-await-statements": "error",
+      "saasmakers/ts-padding-statements": "error",
       "saasmakers/ts-sort-tests": "error"
     }
   },
   // Stylistic
   {
     rules: {
-      "style/padding-line-between-statements": [
-        "error",
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-let",
-          prev: "multiline-let"
-        }
-      ],
       "style/object-property-newline": ["error", { allowAllPropertiesOnSameLine: false }],
       "style/object-curly-newline": ["error", {
         ExportDeclaration: {

package/dist/eslint.config.mjs

@@ -10841,76 +10841,13 @@ const eslint_config = antfu(
   {
     plugins: { saasmakers },
     rules: {
-      "saasmakers/ts-padding-await-statements": "error",
+      "saasmakers/ts-padding-statements": "error",
       "saasmakers/ts-sort-tests": "error"
     }
   },
   // Stylistic
   {
     rules: {
-      "style/padding-line-between-statements": [
-        "error",
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "*",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "never",
-          next: "singleline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "multiline-let"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-const",
-          prev: "singleline-const"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-const",
-          prev: "multiline-const"
-        },
-        {
-          blankLine: "always",
-          next: "multiline-let",
-          prev: "singleline-let"
-        },
-        {
-          blankLine: "always",
-          next: "singleline-let",
-          prev: "multiline-let"
-        }
-      ],
       "style/object-property-newline": ["error", { allowAllPropertiesOnSameLine: false }],
       "style/object-curly-newline": ["error", {
         ExportDeclaration: {

package/dist/index.cjs

@@ -151,41 +151,60 @@ function getActualLastToken(node, sourceCode) {
   }
   return semiToken;
 }
-function getBlankLineRequirement(prevNode, nextNode) {
-  if (!isAwaitStatement(prevNode)) {
+function getBlankLineRequirement(prevNode, nextNode, sourceCode) {
+  const prevKind = getStatementKind(prevNode);
+  if (!prevKind) {
     return null;
   }
-  if (!isAwaitStatement(nextNode)) {
+  if (hasLineCommentBetween(prevNode, nextNode, sourceCode)) {
     return "always";
   }
-  if (isSingleLine(prevNode) && isSingleLine(nextNode)) {
+  const nextKind = getStatementKind(nextNode);
+  if (!nextKind) {
+    return "always";
+  }
+  if (prevKind === nextKind && prevKind.startsWith("singleline-")) {
     return "never";
   }
   return "always";
 }
-function getPaddingLineSequences(prevNode, nextNode, sourceCode) {
-  const pairs = [];
-  const prevToken = getActualLastToken(prevNode, sourceCode);
-  if (!prevToken) {
-    return pairs;
+function getStatementKind(node) {
+  if (node.type === index$1.distExports.AST_NODE_TYPES.VariableDeclaration) {
+    if (node.kind === "const") {
+      return isSingleLine(node) ? "singleline-const" : "multiline-const";
+    }
+    if (node.kind === "let") {
+      return isSingleLine(node) ? "singleline-let" : "multiline-let";
+    }
+    return null;
   }
-  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;
+  if (node.type === index$1.distExports.AST_NODE_TYPES.ExpressionStatement && node.expression.type === index$1.distExports.AST_NODE_TYPES.AwaitExpression) {
+    return isSingleLine(node) ? "singleline-await" : "multiline-await";
+  }
+  return null;
+}
+function hasEmptyLineBetween(prevNode, nextNode, sourceCode) {
+  for (let line = prevNode.loc.end.line + 1; line < nextNode.loc.start.line; line++) {
+    if (sourceCode.lines[line - 1]?.trim() === "") {
+      return true;
     }
   }
-  return pairs;
+  return false;
+}
+function hasLineCommentBetween(prevNode, nextNode, sourceCode) {
+  return sourceCode.getAllComments().some((comment) => {
+    if (comment.type !== "Line") {
+      return false;
+    }
+    return comment.range[0] >= prevNode.range[1] && comment.range[1] <= nextNode.range[0];
+  });
 }
-function isAwaitStatement(node) {
-  return node.type === index$1.distExports.AST_NODE_TYPES.ExpressionStatement && node.expression.type === index$1.distExports.AST_NODE_TYPES.AwaitExpression;
+function isOwnLineComment(comment, sourceCode) {
+  if (comment.type !== "Line") {
+    return false;
+  }
+  const lineText = sourceCode.lines[comment.loc.start.line - 1] ?? "";
+  return lineText.trimStart().startsWith("//");
 }
 function isSingleLine(node) {
   return node.loc.start.line === node.loc.end.line;
@@ -193,10 +212,11 @@ function isSingleLine(node) {
 const rule$a = {
   defaultOptions: [],
   meta: {
-    docs: { description: "Require or disallow padding lines between standalone await statements" },
+    docs: { description: "Require or disallow padding lines between const, let, and standalone await statements" },
     fixable: "whitespace",
     messages: {
       expectedBlankLine: "Expected blank line before this statement.",
+      expectedBlankLineBeforeComment: "Expected blank line before this comment.",
       unexpectedBlankLine: "Unexpected blank line before this statement."
     },
     schema: [],
@@ -216,6 +236,57 @@ const rule$a = {
         scopeInfo = scopeInfo.upper;
       }
     }
+    function reportMissingBlankLine(prevNode, node) {
+      context.report({
+        fix(fixer) {
+          const lastToken = getActualLastToken(prevNode, sourceCode);
+          if (!lastToken) {
+            return null;
+          }
+          return fixer.insertTextAfter(lastToken, "\n");
+        },
+        messageId: "expectedBlankLine",
+        node
+      });
+    }
+    function reportUnexpectedBlankLine(prevNode, node) {
+      context.report({
+        fix(fixer) {
+          const lastToken = getActualLastToken(prevNode, sourceCode);
+          const firstToken = sourceCode.getFirstToken(node);
+          if (!lastToken || !firstToken) {
+            return null;
+          }
+          const start = lastToken.range[1];
+          const end = firstToken.range[0];
+          const text = collapseBlankLine(sourceCode.text.slice(start, end));
+          return fixer.replaceTextRange([start, end], text);
+        },
+        messageId: "unexpectedBlankLine",
+        node
+      });
+    }
+    function verifyComment(comment) {
+      if (!isOwnLineComment(comment, sourceCode)) {
+        return;
+      }
+      const commentLine = comment.loc.start.line;
+      if (commentLine <= 1) {
+        return;
+      }
+      const previousLine = sourceCode.lines[commentLine - 2] ?? "";
+      if (previousLine.trim() === "" || previousLine.trimEnd().endsWith("{")) {
+        return;
+      }
+      context.report({
+        fix(fixer) {
+          return fixer.insertTextBefore(comment, "\n");
+        },
+        loc: comment.loc,
+        messageId: "expectedBlankLineBeforeComment",
+        node: comment
+      });
+    }
     function verify(node) {
       const parentType = node.parent?.type;
       const allowedParents = /* @__PURE__ */ new Set([
@@ -229,48 +300,13 @@ const rule$a = {
       }
       const prevNode = scopeInfo?.prevNode;
       if (prevNode) {
-        const requirement = getBlankLineRequirement(prevNode, node);
+        const requirement = getBlankLineRequirement(prevNode, node, sourceCode);
         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
-            });
+          const hasBlank = hasEmptyLineBetween(prevNode, node, sourceCode);
+          if (requirement === "never" && hasBlank) {
+            reportUnexpectedBlankLine(prevNode, node);
+          } else if (requirement === "always" && !hasBlank) {
+            reportMissingBlankLine(prevNode, node);
           }
         }
       }
@@ -286,6 +322,7 @@ const rule$a = {
       ":statement": verify,
       "BlockStatement": enterScope,
       "BlockStatement:exit": exitScope,
+      "LineComment": verifyComment,
       "Program": enterScope,
       "Program:exit": exitScope,
       "StaticBlock": enterScope,
@@ -1024,7 +1061,7 @@ const index = {
   rules: {
     "ts-multiline-ternary": rule$c,
     "ts-multiline-union": rule$b,
-    "ts-padding-await-statements": rule$a,
+    "ts-padding-statements": rule$a,
     "ts-sort-tests": rule$9,
     "vue-i18n-consistent-locales": rule$8,
     "vue-i18n-consistent-t": rule$7,

package/dist/index.d.cts

@@ -7526,7 +7526,7 @@ declare const _default: {
     rules: {
         'ts-multiline-ternary': eslint.Rule.RuleModule;
         'ts-multiline-union': eslint.Rule.RuleModule;
-        'ts-padding-await-statements': RuleModule<"expectedBlankLine" | "unexpectedBlankLine", [], unknown, RuleListener>;
+        'ts-padding-statements': RuleModule<"expectedBlankLine" | "expectedBlankLineBeforeComment" | "unexpectedBlankLine", [], unknown, RuleListener>;
         'ts-sort-tests': eslint.Rule.RuleModule;
         'vue-i18n-consistent-locales': eslint.Rule.RuleModule;
         'vue-i18n-consistent-t': eslint.Rule.RuleModule;

package/dist/index.d.mts

@@ -7526,7 +7526,7 @@ declare const _default: {
     rules: {
         'ts-multiline-ternary': eslint.Rule.RuleModule;
         'ts-multiline-union': eslint.Rule.RuleModule;
-        'ts-padding-await-statements': RuleModule<"expectedBlankLine" | "unexpectedBlankLine", [], unknown, RuleListener>;
+        'ts-padding-statements': RuleModule<"expectedBlankLine" | "expectedBlankLineBeforeComment" | "unexpectedBlankLine", [], unknown, RuleListener>;
         'ts-sort-tests': eslint.Rule.RuleModule;
         'vue-i18n-consistent-locales': eslint.Rule.RuleModule;
         'vue-i18n-consistent-t': eslint.Rule.RuleModule;

package/dist/index.d.ts

@@ -7526,7 +7526,7 @@ declare const _default: {
     rules: {
         'ts-multiline-ternary': eslint.Rule.RuleModule;
         'ts-multiline-union': eslint.Rule.RuleModule;
-        'ts-padding-await-statements': RuleModule<"expectedBlankLine" | "unexpectedBlankLine", [], unknown, RuleListener>;
+        'ts-padding-statements': RuleModule<"expectedBlankLine" | "expectedBlankLineBeforeComment" | "unexpectedBlankLine", [], unknown, RuleListener>;
         'ts-sort-tests': eslint.Rule.RuleModule;
         'vue-i18n-consistent-locales': eslint.Rule.RuleModule;
         'vue-i18n-consistent-t': eslint.Rule.RuleModule;

package/dist/index.mjs

@@ -149,41 +149,60 @@ function getActualLastToken(node, sourceCode) {
   }
   return semiToken;
 }
-function getBlankLineRequirement(prevNode, nextNode) {
-  if (!isAwaitStatement(prevNode)) {
+function getBlankLineRequirement(prevNode, nextNode, sourceCode) {
+  const prevKind = getStatementKind(prevNode);
+  if (!prevKind) {
     return null;
   }
-  if (!isAwaitStatement(nextNode)) {
+  if (hasLineCommentBetween(prevNode, nextNode, sourceCode)) {
     return "always";
   }
-  if (isSingleLine(prevNode) && isSingleLine(nextNode)) {
+  const nextKind = getStatementKind(nextNode);
+  if (!nextKind) {
+    return "always";
+  }
+  if (prevKind === nextKind && prevKind.startsWith("singleline-")) {
     return "never";
   }
   return "always";
 }
-function getPaddingLineSequences(prevNode, nextNode, sourceCode) {
-  const pairs = [];
-  const prevToken = getActualLastToken(prevNode, sourceCode);
-  if (!prevToken) {
-    return pairs;
+function getStatementKind(node) {
+  if (node.type === distExports.AST_NODE_TYPES.VariableDeclaration) {
+    if (node.kind === "const") {
+      return isSingleLine(node) ? "singleline-const" : "multiline-const";
+    }
+    if (node.kind === "let") {
+      return isSingleLine(node) ? "singleline-let" : "multiline-let";
+    }
+    return null;
   }
-  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;
+  if (node.type === distExports.AST_NODE_TYPES.ExpressionStatement && node.expression.type === distExports.AST_NODE_TYPES.AwaitExpression) {
+    return isSingleLine(node) ? "singleline-await" : "multiline-await";
+  }
+  return null;
+}
+function hasEmptyLineBetween(prevNode, nextNode, sourceCode) {
+  for (let line = prevNode.loc.end.line + 1; line < nextNode.loc.start.line; line++) {
+    if (sourceCode.lines[line - 1]?.trim() === "") {
+      return true;
     }
   }
-  return pairs;
+  return false;
+}
+function hasLineCommentBetween(prevNode, nextNode, sourceCode) {
+  return sourceCode.getAllComments().some((comment) => {
+    if (comment.type !== "Line") {
+      return false;
+    }
+    return comment.range[0] >= prevNode.range[1] && comment.range[1] <= nextNode.range[0];
+  });
 }
-function isAwaitStatement(node) {
-  return node.type === distExports.AST_NODE_TYPES.ExpressionStatement && node.expression.type === distExports.AST_NODE_TYPES.AwaitExpression;
+function isOwnLineComment(comment, sourceCode) {
+  if (comment.type !== "Line") {
+    return false;
+  }
+  const lineText = sourceCode.lines[comment.loc.start.line - 1] ?? "";
+  return lineText.trimStart().startsWith("//");
 }
 function isSingleLine(node) {
   return node.loc.start.line === node.loc.end.line;
@@ -191,10 +210,11 @@ function isSingleLine(node) {
 const rule$a = {
   defaultOptions: [],
   meta: {
-    docs: { description: "Require or disallow padding lines between standalone await statements" },
+    docs: { description: "Require or disallow padding lines between const, let, and standalone await statements" },
     fixable: "whitespace",
     messages: {
       expectedBlankLine: "Expected blank line before this statement.",
+      expectedBlankLineBeforeComment: "Expected blank line before this comment.",
       unexpectedBlankLine: "Unexpected blank line before this statement."
     },
     schema: [],
@@ -214,6 +234,57 @@ const rule$a = {
         scopeInfo = scopeInfo.upper;
       }
     }
+    function reportMissingBlankLine(prevNode, node) {
+      context.report({
+        fix(fixer) {
+          const lastToken = getActualLastToken(prevNode, sourceCode);
+          if (!lastToken) {
+            return null;
+          }
+          return fixer.insertTextAfter(lastToken, "\n");
+        },
+        messageId: "expectedBlankLine",
+        node
+      });
+    }
+    function reportUnexpectedBlankLine(prevNode, node) {
+      context.report({
+        fix(fixer) {
+          const lastToken = getActualLastToken(prevNode, sourceCode);
+          const firstToken = sourceCode.getFirstToken(node);
+          if (!lastToken || !firstToken) {
+            return null;
+          }
+          const start = lastToken.range[1];
+          const end = firstToken.range[0];
+          const text = collapseBlankLine(sourceCode.text.slice(start, end));
+          return fixer.replaceTextRange([start, end], text);
+        },
+        messageId: "unexpectedBlankLine",
+        node
+      });
+    }
+    function verifyComment(comment) {
+      if (!isOwnLineComment(comment, sourceCode)) {
+        return;
+      }
+      const commentLine = comment.loc.start.line;
+      if (commentLine <= 1) {
+        return;
+      }
+      const previousLine = sourceCode.lines[commentLine - 2] ?? "";
+      if (previousLine.trim() === "" || previousLine.trimEnd().endsWith("{")) {
+        return;
+      }
+      context.report({
+        fix(fixer) {
+          return fixer.insertTextBefore(comment, "\n");
+        },
+        loc: comment.loc,
+        messageId: "expectedBlankLineBeforeComment",
+        node: comment
+      });
+    }
     function verify(node) {
       const parentType = node.parent?.type;
       const allowedParents = /* @__PURE__ */ new Set([
@@ -227,48 +298,13 @@ const rule$a = {
       }
       const prevNode = scopeInfo?.prevNode;
       if (prevNode) {
-        const requirement = getBlankLineRequirement(prevNode, node);
+        const requirement = getBlankLineRequirement(prevNode, node, sourceCode);
         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
-            });
+          const hasBlank = hasEmptyLineBetween(prevNode, node, sourceCode);
+          if (requirement === "never" && hasBlank) {
+            reportUnexpectedBlankLine(prevNode, node);
+          } else if (requirement === "always" && !hasBlank) {
+            reportMissingBlankLine(prevNode, node);
           }
         }
       }
@@ -284,6 +320,7 @@ const rule$a = {
       ":statement": verify,
       "BlockStatement": enterScope,
       "BlockStatement:exit": exitScope,
+      "LineComment": verifyComment,
       "Program": enterScope,
       "Program:exit": exitScope,
       "StaticBlock": enterScope,
@@ -1022,7 +1059,7 @@ const index = {
   rules: {
     "ts-multiline-ternary": rule$c,
     "ts-multiline-union": rule$b,
-    "ts-padding-await-statements": rule$a,
+    "ts-padding-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.6",
+  "version": "1.0.8",
   "private": false,
   "description": "Shared ESLint config and rules for SaaS Makers projects",
   "license": "MIT",