@saasmakers/eslint 1.0.5 → 1.0.6

package/dist/eslint.config.cjs

@@ -10866,11 +10866,77 @@ const eslint_config = antfu__default(
   // SaaS Makers
   {
     plugins: { saasmakers: saasmakers__default },
-    rules: { "saasmakers/ts-sort-tests": "error" }
+    rules: {
+      "saasmakers/ts-padding-await-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

@@ -146,11 +146,77 @@ var eslint_config = antfu(
   // SaaS Makers
   {
     plugins: { saasmakers },
-    rules: { "saasmakers/ts-sort-tests": "error" }
+    rules: {
+      "saasmakers/ts-padding-await-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

@@ -146,11 +146,77 @@ var eslint_config = antfu(
   // SaaS Makers
   {
     plugins: { saasmakers },
-    rules: { "saasmakers/ts-sort-tests": "error" }
+    rules: {
+      "saasmakers/ts-padding-await-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

@@ -146,11 +146,77 @@ var eslint_config = antfu(
   // SaaS Makers
   {
     plugins: { saasmakers },
-    rules: { "saasmakers/ts-sort-tests": "error" }
+    rules: {
+      "saasmakers/ts-padding-await-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

@@ -10840,11 +10840,77 @@ const eslint_config = antfu(
   // SaaS Makers
   {
     plugins: { saasmakers },
-    rules: { "saasmakers/ts-sort-tests": "error" }
+    rules: {
+      "saasmakers/ts-padding-await-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

@@ -4,7 +4,7 @@ const index$1 = require('./shared/eslint.DhFjwkxh.cjs');
 require('eslint');
 require('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",
@@ -66,7 +66,7 @@ const rule$b = {
   }
 };
 
-const rule$a = {
+const rule$b = {
   meta: {
     docs: {
       description: "Enforce multiline formatting for union types with more than N items",
@@ -136,6 +136,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 === index$1.distExports.AST_NODE_TYPES.ExpressionStatement && node.expression.type === index$1.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([
+        index$1.distExports.AST_NODE_TYPES.BlockStatement,
+        index$1.distExports.AST_NODE_TYPES.Program,
+        index$1.distExports.AST_NODE_TYPES.StaticBlock,
+        index$1.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);
@@ -862,8 +1022,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/dist/index.d.cts

@@ -7526,6 +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-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,6 +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-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,6 +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-sort-tests': eslint.Rule.RuleModule;
         'vue-i18n-consistent-locales': eslint.Rule.RuleModule;
         'vue-i18n-consistent-t': eslint.Rule.RuleModule;

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.5",
+  "version": "1.0.6",
   "private": false,
   "description": "Shared ESLint config and rules for SaaS Makers projects",
   "license": "MIT",
@@ -30,7 +30,7 @@
     "@unocss/eslint-plugin": "66.7.0",
     "@vitest/eslint-plugin": "1.6.20",
     "eslint-plugin-package-json": "0.31.0",
-    "eslint-plugin-turbo": "2.9.17",
+    "eslint-plugin-turbo": "2.9.18",
     "eslint-plugin-zod": "3.4.0",
     "typescript-eslint": "8.61.0"
   },