@saasmakers/eslint 1.0.7 → 1.0.9

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,23 +151,72 @@ 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 hasBlankLineBetween(prevNode, nextNode) {
-  return nextNode.loc.start.line - prevNode.loc.end.line > 1;
+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 (node.type === index$1.distExports.AST_NODE_TYPES.ExpressionStatement) {
+    if (node.expression.type === index$1.distExports.AST_NODE_TYPES.AwaitExpression) {
+      return isSingleLine(node) ? "singleline-await" : "multiline-await";
+    }
+    if (isDirectivePrologue(node)) {
+      return null;
+    }
+    return isSingleLine(node) ? "singleline-expression" : "multiline-expression";
+  }
+  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 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 isDirectivePrologue(node) {
+  if (node.expression.type !== index$1.distExports.AST_NODE_TYPES.Literal) {
+    return false;
+  }
+  return typeof node.expression.value === "string";
 }
-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;
@@ -175,10 +224,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, await, and expression 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: [],
@@ -198,6 +248,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([
@@ -211,37 +312,13 @@ const rule$a = {
       }
       const prevNode = scopeInfo?.prevNode;
       if (prevNode) {
-        const requirement = getBlankLineRequirement(prevNode, node);
+        const requirement = getBlankLineRequirement(prevNode, node, sourceCode);
         if (requirement) {
-          const hasBlank = hasBlankLineBetween(prevNode, node);
+          const hasBlank = hasEmptyLineBetween(prevNode, node, sourceCode);
           if (requirement === "never" && hasBlank) {
-            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
-            });
+            reportUnexpectedBlankLine(prevNode, node);
           } else if (requirement === "always" && !hasBlank) {
-            context.report({
-              fix(fixer) {
-                const lastToken = getActualLastToken(prevNode, sourceCode);
-                if (!lastToken) {
-                  return null;
-                }
-                return fixer.insertTextAfter(lastToken, "\n");
-              },
-              messageId: "expectedBlankLine",
-              node
-            });
+            reportMissingBlankLine(prevNode, node);
           }
         }
       }
@@ -257,6 +334,7 @@ const rule$a = {
       ":statement": verify,
       "BlockStatement": enterScope,
       "BlockStatement:exit": exitScope,
+      "LineComment": verifyComment,
       "Program": enterScope,
       "Program:exit": exitScope,
       "StaticBlock": enterScope,
@@ -995,7 +1073,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,23 +149,72 @@ 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 hasBlankLineBetween(prevNode, nextNode) {
-  return nextNode.loc.start.line - prevNode.loc.end.line > 1;
+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 (node.type === distExports.AST_NODE_TYPES.ExpressionStatement) {
+    if (node.expression.type === distExports.AST_NODE_TYPES.AwaitExpression) {
+      return isSingleLine(node) ? "singleline-await" : "multiline-await";
+    }
+    if (isDirectivePrologue(node)) {
+      return null;
+    }
+    return isSingleLine(node) ? "singleline-expression" : "multiline-expression";
+  }
+  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 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 isDirectivePrologue(node) {
+  if (node.expression.type !== distExports.AST_NODE_TYPES.Literal) {
+    return false;
+  }
+  return typeof node.expression.value === "string";
 }
-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;
@@ -173,10 +222,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, await, and expression 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: [],
@@ -196,6 +246,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([
@@ -209,37 +310,13 @@ const rule$a = {
       }
       const prevNode = scopeInfo?.prevNode;
       if (prevNode) {
-        const requirement = getBlankLineRequirement(prevNode, node);
+        const requirement = getBlankLineRequirement(prevNode, node, sourceCode);
         if (requirement) {
-          const hasBlank = hasBlankLineBetween(prevNode, node);
+          const hasBlank = hasEmptyLineBetween(prevNode, node, sourceCode);
           if (requirement === "never" && hasBlank) {
-            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
-            });
+            reportUnexpectedBlankLine(prevNode, node);
           } else if (requirement === "always" && !hasBlank) {
-            context.report({
-              fix(fixer) {
-                const lastToken = getActualLastToken(prevNode, sourceCode);
-                if (!lastToken) {
-                  return null;
-                }
-                return fixer.insertTextAfter(lastToken, "\n");
-              },
-              messageId: "expectedBlankLine",
-              node
-            });
+            reportMissingBlankLine(prevNode, node);
           }
         }
       }
@@ -255,6 +332,7 @@ const rule$a = {
       ":statement": verify,
       "BlockStatement": enterScope,
       "BlockStatement:exit": exitScope,
+      "LineComment": verifyComment,
       "Program": enterScope,
       "Program:exit": exitScope,
       "StaticBlock": enterScope,
@@ -993,7 +1071,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.7",
+  "version": "1.0.9",
   "private": false,
   "description": "Shared ESLint config and rules for SaaS Makers projects",
   "license": "MIT",