@saasmakers/eslint 1.0.18 → 1.0.20

package/dist/index.mjs

@@ -1,139 +1,63 @@
-import { d as distExports } from './shared/eslint.CohBuu1-.mjs';
+import { d as distExports } from './shared/eslint.DOaqyhfZ.mjs';
 import 'eslint';
 import 'eslint/use-at-your-own-risk';
 
-const rule$c = {
-  meta: {
-    docs: {
-      description: "Enforce one-line ternaries if under a character limit, multiline otherwise",
-      recommended: true
-    },
-    fixable: "whitespace",
-    messages: {
-      multiline: "Ternary expression should be multiline when it exceeds max characters.",
-      singleLine: "Ternary expression should be single-line when it is under max characters."
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { maxCharacters: { type: "number" } },
-        type: "object"
-      }
-    ],
-    type: "layout"
-  },
-  create(context) {
-    const maxCharacters = context.options[0]?.maxCharacters ?? 100;
-    return {
-      ConditionalExpression(node) {
-        if (node.type !== distExports.AST_NODE_TYPES.ConditionalExpression) {
-          return;
-        }
-        const sourceCode = context.sourceCode;
-        const ternaryText = sourceCode.getText(node);
-        const isMultiline = ternaryText.includes("\n");
-        const isOverMaxLength = ternaryText.length > maxCharacters;
-        if (isOverMaxLength && !isMultiline) {
-          context.report({
-            fix: (fixer) => {
-              const [
-                test,
-                consequent,
-                alternate
-              ] = [
-                node.test,
-                node.consequent,
-                node.alternate
-              ].map((part) => sourceCode.getText(part));
-              return fixer.replaceText(node, `${test} ?
+const defaultMaxCharacters = 100;
+const defaultMaxLineLength = 100;
+const defaultMinItems = 5;
+function checkTernary(context, node, maxCharacters) {
+  const sourceCode = context.sourceCode;
+  const ternaryText = sourceCode.getText(node);
+  const isMultiline = ternaryText.includes("\n");
+  const isOverMaxLength = ternaryText.length > maxCharacters;
+  if (isOverMaxLength && !isMultiline) {
+    context.report({
+      fix: (fixer) => {
+        const [test, consequent, alternate] = [node.test, node.consequent, node.alternate].map((part) => sourceCode.getText(part));
+        return fixer.replaceText(node, `${test} ?
   ${consequent} :
   ${alternate}`);
-            },
-            messageId: "multiline",
-            node
-          });
-        } else if (!isOverMaxLength && isMultiline) {
-          context.report({
-            fix: (fixer) => fixer.replaceText(node, ternaryText.replaceAll(/\s+/g, " ")),
-            messageId: "singleLine",
-            node
-          });
-        }
-      }
-    };
+      },
+      messageId: "ternaryMultiline",
+      node
+    });
+  } else if (!isOverMaxLength && isMultiline) {
+    context.report({
+      fix: (fixer) => fixer.replaceText(node, ternaryText.replaceAll(/\s+/g, " ")),
+      messageId: "ternarySingleLine",
+      node
+    });
   }
-};
-
-const rule$b = {
-  meta: {
-    docs: {
-      description: "Enforce multiline formatting for union types with more than N items",
-      recommended: false
-    },
-    fixable: "whitespace",
-    messages: {
-      multiline: "Union type should be multiline when it exceeds max length or has too many items.",
-      singleLine: "Union type should be single-line when it is under max length and has few items."
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          maxLineLength: { type: "number" },
-          minItems: { type: "number" }
-        },
-        type: "object"
-      }
-    ],
-    type: "layout"
-  },
-  create(context) {
-    const minItems = context.options[0]?.minItems ?? 5;
-    const maxLineLength = context.options[0]?.maxLineLength ?? 100;
-    function reportAndFix(node, messageId, fixFunction) {
-      context.report({
-        fix: fixFunction,
-        messageId,
-        node
-      });
-    }
-    return {
-      // @ts-expect-error TSUnionType is not the right type
-      TSUnionType(node) {
-        const sourceCode = context.sourceCode;
-        const unionText = sourceCode.getText(node);
-        const isMultiline = unionText.includes("\n");
-        const isOverMaxLength = unionText.length > maxLineLength;
-        const hasEnoughItems = node.types.length >= minItems;
-        if ((isOverMaxLength || hasEnoughItems) && !isMultiline) {
-          reportAndFix(
-            node,
-            "multiline",
-            (fixer) => {
-              const types = node.types.map((type) => {
-                return sourceCode.getText(type);
-              });
-              return fixer.replaceText(node, `
+}
+function checkUnion(context, node, maxLineLength, minItems) {
+  const sourceCode = context.sourceCode;
+  const unionText = sourceCode.getText(node);
+  const isMultiline = unionText.includes("\n");
+  const isOverMaxLength = unionText.length > maxLineLength;
+  const hasEnoughItems = node.types.length >= minItems;
+  if ((isOverMaxLength || hasEnoughItems) && !isMultiline) {
+    context.report({
+      fix: (fixer) => {
+        const types = node.types.map((type) => sourceCode.getText(type));
+        return fixer.replaceText(node, `
   | ${types.join("\n  | ")}`);
-            }
-          );
-        } else if (!isOverMaxLength && !hasEnoughItems && isMultiline) {
-          reportAndFix(
-            node,
-            "singleLine",
-            (fixer) => {
-              let singleLineText = unionText.replaceAll(/[ \t\n]+/g, " ");
-              singleLineText = singleLineText.replaceAll(" |", "|").replaceAll("|", " |");
-              singleLineText = singleLineText.replaceAll("  ", " ");
-              return fixer.replaceText(node, singleLineText);
-            }
-          );
-        }
-      }
-    };
+      },
+      messageId: "unionMultiline",
+      node
+    });
+  } else if (!isOverMaxLength && !hasEnoughItems && isMultiline) {
+    context.report({
+      fix: (fixer) => {
+        let singleLineText = unionText.replaceAll(/[ \t\n]+/g, " ");
+        singleLineText = singleLineText.replaceAll(" |", "|").replaceAll("|", " |");
+        singleLineText = singleLineText.replaceAll("  ", " ");
+        return fixer.replaceText(node, singleLineText);
+      },
+      messageId: "unionSingleLine",
+      node
+    });
   }
-};
-
+}
 function collapseBlankLine(text) {
   return text.replace(/\n[^\S\n]*\n[^\S\n]*/, "\n");
 }
@@ -191,7 +115,7 @@ function getBlankLineRequirement(prevNode, nextNode, sourceCode) {
     return null;
   }
   if (hasLineCommentBetween(prevNode, nextNode, sourceCode)) {
-    return "always";
+    return null;
   }
   const nextKind = getStatementKind(nextNode);
   if (!nextKind) {
@@ -327,21 +251,38 @@ function isThisReceiver(node) {
 function isVoidExpression(expression) {
   return expression.type === distExports.AST_NODE_TYPES.UnaryExpression && expression.operator === "void";
 }
-const rule$a = {
-  defaultOptions: [],
+const rule$4 = {
+  defaultOptions: [{}],
   meta: {
-    docs: { description: "Require or disallow padding lines between const, let, await, and expression statements" },
+    docs: { description: "Format TypeScript layout: single/multiline ternaries and union types, and blank lines between 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."
+      ternaryMultiline: "Ternary expression should be multiline when it exceeds max characters.",
+      ternarySingleLine: "Ternary expression should be single-line when it is under max characters.",
+      unexpectedBlankLine: "Unexpected blank line before this statement.",
+      unionMultiline: "Union type should be multiline when it exceeds max length or has too many items.",
+      unionSingleLine: "Union type should be single-line when it is under max length and has few items."
     },
-    schema: [],
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          maxCharacters: { type: "number" },
+          maxLineLength: { type: "number" },
+          minItems: { type: "number" }
+        },
+        type: "object"
+      }
+    ],
     type: "layout"
   },
   create(context) {
     const sourceCode = context.sourceCode;
+    const maxCharacters = context.options[0]?.maxCharacters ?? defaultMaxCharacters;
+    const maxLineLength = context.options[0]?.maxLineLength ?? defaultMaxLineLength;
+    const minItems = context.options[0]?.minItems ?? defaultMinItems;
     let scopeInfo = null;
     function enterScope() {
       scopeInfo = {
@@ -393,7 +334,7 @@ const rule$a = {
         return;
       }
       const previousLine = sourceCode.lines[commentLine - 2] ?? "";
-      if (previousLine.trim() === "" || previousLine.trimEnd().endsWith("{")) {
+      if (previousLine.trim() === "" || previousLine.trimEnd().endsWith("{") || previousLine.trimStart().startsWith("//")) {
         return;
       }
       context.report({
@@ -440,13 +381,19 @@ const rule$a = {
       ":statement": verify,
       "BlockStatement": enterScope,
       "BlockStatement:exit": exitScope,
-      "LineComment": verifyComment,
+      "ConditionalExpression": (node) => checkTernary(context, node, maxCharacters),
       "Program": enterScope,
-      "Program:exit": exitScope,
+      "Program:exit": function() {
+        for (const comment of sourceCode.getAllComments()) {
+          verifyComment(comment);
+        }
+        exitScope();
+      },
       "StaticBlock": enterScope,
       "StaticBlock:exit": exitScope,
       "SwitchCase": verifyThenEnterScope,
-      "SwitchCase:exit": exitScope
+      "SwitchCase:exit": exitScope,
+      "TSUnionType": (node) => checkUnion(context, node, maxLineLength, minItems)
     };
   }
 };
@@ -480,8 +427,9 @@ function getSpecificName(testName) {
   return parts.slice(specialIndex + 1).join(".");
 }
 function getTestName(node) {
-  if (node.arguments && node.arguments[0] && node.arguments[0].type === "Literal") {
-    return node.arguments[0].value;
+  const firstArgument = node.arguments[0];
+  if (firstArgument?.type === distExports.AST_NODE_TYPES.Literal && typeof firstArgument.value === "string") {
+    return firstArgument.value;
   }
   return "";
 }
@@ -498,12 +446,10 @@ function getTestPriority(testName) {
     return 1;
   }
 }
-const rule$9 = {
+const rule$3 = {
+  defaultOptions: [],
   meta: {
-    docs: {
-      description: "Enforce sorted test functions grouped by method with sorted metrics, errors, exceptions and middlewares",
-      recommended: true
-    },
+    docs: { description: "Enforce sorted test functions grouped by method with sorted metrics, errors, exceptions and middlewares" },
     fixable: "code",
     messages: { sortError: "Test functions should be grouped by method with sorted metrics, errors, exceptions and middlewares." },
     schema: [],
@@ -519,15 +465,15 @@ const rule$9 = {
         return;
       }
       const groupCallback = node.arguments[1];
-      if (groupCallback.type !== "FunctionExpression" && groupCallback.type !== "ArrowFunctionExpression") {
+      if (groupCallback.type !== distExports.AST_NODE_TYPES.FunctionExpression && groupCallback.type !== distExports.AST_NODE_TYPES.ArrowFunctionExpression) {
         return;
       }
       const callbackBody = groupCallback.body;
-      if (callbackBody.type !== "BlockStatement" || !callbackBody.body) {
+      if (callbackBody.type !== distExports.AST_NODE_TYPES.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");
+        return statement.type === distExports.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === distExports.AST_NODE_TYPES.CallExpression && statement.expression.callee.type === distExports.AST_NODE_TYPES.Identifier && (statement.expression.callee.name === "test" || statement.expression.callee.name === "it");
       });
       const testNames = tests.map((test) => getTestName(test.expression));
       const sortedTestNames = [...testNames].toSorted(compareTests);
@@ -567,63 +513,68 @@ const rule$9 = {
   }
 };
 
-function checkInvalidLocales(context, parsed, locales, startOffset, i18nContent) {
+const defaultLocales = ["en", "fr"];
+const indentSpaces = 2;
+const i18nRegex = /(<i18n\s+lang=["']json["']>)([\s\S]*?)<\/i18n>/i;
+const templateRegex$1 = /<template>([\s\S]*)<\/template>/i;
+const scriptRegex = /<script[^>]*>([\s\S]*?)<\/script>/i;
+function checkInvalidLocales(context, parsed, locales, content, contentOffset) {
   for (const locale of Object.keys(parsed)) {
-    if (!locales.includes(locale)) {
-      const escapedLocale = locale.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-      const localeMatch = new RegExp(String.raw`"${escapedLocale}"\s*:`, "g").exec(i18nContent);
-      if (localeMatch) {
-        const localeOffset = startOffset + localeMatch.index;
-        context.report({
-          data: {
-            allowed: locales.join(", "),
-            locale
-          },
-          loc: {
-            end: context.sourceCode.getLocFromIndex(localeOffset + locale.length + 2),
-            start: context.sourceCode.getLocFromIndex(localeOffset)
-          },
-          messageId: "invalidLocale"
-        });
-      }
+    if (locales.includes(locale)) {
+      continue;
+    }
+    const localeMatch = new RegExp(String.raw`"${escapeRegExp(locale)}"\s*:`, "g").exec(content);
+    if (localeMatch) {
+      const localeOffset = contentOffset + localeMatch.index;
+      context.report({
+        data: {
+          allowed: locales.join(", "),
+          locale
+        },
+        loc: {
+          end: context.sourceCode.getLocFromIndex(localeOffset + locale.length + 2),
+          start: context.sourceCode.getLocFromIndex(localeOffset)
+        },
+        messageId: "invalidLocale"
+      });
     }
   }
 }
-function checkMissingLocales(context, parsed, locales, startOffset, i18nContent) {
+function checkMissingLocales(context, parsed, locales, content, contentOffset) {
   for (const locale of locales) {
     if (!parsed[locale]) {
       context.report({
         data: { locale },
         loc: {
-          end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-          start: context.sourceCode.getLocFromIndex(startOffset)
+          end: context.sourceCode.getLocFromIndex(contentOffset + content.length),
+          start: context.sourceCode.getLocFromIndex(contentOffset)
         },
         messageId: "missingLocale"
       });
     }
   }
 }
-function checkMissingTranslations(context, parsed, locales, startOffset, i18nContent) {
+function checkMissingTranslations(context, parsed, locales, content, contentOffset) {
   const allKeys = /* @__PURE__ */ new Set();
   for (const locale of locales) {
     if (parsed[locale]) {
-      const keys = getAllKeys$1(parsed[locale]);
-      for (const key of keys) allKeys.add(key);
+      for (const key of getAllKeys(parsed[locale])) {
+        allKeys.add(key);
+      }
     }
   }
   for (const locale of locales) {
     if (!parsed[locale]) {
       continue;
     }
-    const localeKeys = getAllKeys$1(parsed[locale]);
+    const localeKeys = getAllKeys(parsed[locale]);
     const missingKeys = [...allKeys].filter((key) => !localeKeys.includes(key));
     if (missingKeys.length === 0) {
       continue;
     }
-    const escapedLocale = locale.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-    const localeMatch = new RegExp(String.raw`"${escapedLocale}"\s*:\s*\{`, "g").exec(i18nContent);
+    const localeMatch = new RegExp(String.raw`"${escapeRegExp(locale)}"\s*:\s*\{`, "g").exec(content);
     if (localeMatch) {
-      const localeOffset = startOffset + localeMatch.index;
+      const localeOffset = contentOffset + localeMatch.index;
       context.report({
         data: {
           locale,
@@ -638,152 +589,21 @@ function checkMissingTranslations(context, parsed, locales, startOffset, i18nCon
     }
   }
 }
-function getAllKeys$1(object, prefix = "") {
+function escapeRegExp(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+function getAllKeys(object, prefix = "") {
   let keys = [];
   for (const key in object) {
     const newPrefix = prefix ? `${prefix}.${key}` : key;
     if (typeof object[key] === "object" && object[key] !== null) {
-      keys = [...keys, ...getAllKeys$1(object[key], newPrefix)];
+      keys = [...keys, ...getAllKeys(object[key], newPrefix)];
     } else {
       keys.push(newPrefix);
     }
   }
   return keys;
 }
-const rule$8 = {
-  meta: {
-    docs: {
-      description: "Enforce consistent i18n locale keys across translations",
-      recommended: true
-    },
-    messages: {
-      invalidJson: "Invalid JSON in i18n block: {{error}}",
-      invalidLocale: "Invalid locale: {{locale}}. Allowed locales are: {{allowed}}",
-      missingLocale: "Missing required locale: {{locale}}",
-      missingTranslations: 'Missing translations in "{{locale}}" locale: {{missing}}'
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          locales: {
-            items: { type: "string" },
-            type: "array"
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    const locales = context.options[0]?.locales || ["en", "fr"];
-    return {
-      Program() {
-        const source = context.sourceCode.getText();
-        const i18nRegex = /<i18n\s+lang=["']json["']>([\s\S]*?)<\/i18n>/i;
-        const i18nMatch = i18nRegex.exec(source);
-        if (!i18nMatch) {
-          return;
-        }
-        const tagLength = source.indexOf(">", i18nMatch.index) + 1 - i18nMatch.index;
-        const startOffset = i18nMatch.index + tagLength;
-        const i18nContent = i18nMatch[1].trim();
-        try {
-          const parsed = JSON.parse(i18nContent);
-          checkMissingLocales(context, parsed, locales, startOffset, i18nContent);
-          checkInvalidLocales(context, parsed, locales, startOffset, i18nContent);
-          checkMissingTranslations(context, parsed, locales, startOffset, i18nContent);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          context.report({
-            data: { error: errorMessage },
-            loc: {
-              end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-              start: context.sourceCode.getLocFromIndex(startOffset)
-            },
-            messageId: "invalidJson"
-          });
-        }
-      }
-    };
-  }
-};
-
-const rule$7 = {
-  meta: {
-    docs: {
-      description: "Enforce using t() instead of $t() in Vue templates",
-      recommended: true
-    },
-    fixable: "code",
-    messages: { useT: "Use t() instead of $t() in Vue templates as it does not work with <i18n> tags." },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      Program() {
-        const sourceCode = context.sourceCode;
-        const source = sourceCode.getText();
-        const templateRegex = /<template>([\s\S]*)<\/template>/i;
-        const templateMatch = templateRegex.exec(source);
-        if (!templateMatch) {
-          return;
-        }
-        const templateContent = templateMatch[1];
-        const tPatterns = [
-          {
-            pattern: / \$t\(/g,
-            quote: " "
-          },
-          {
-            pattern: /"\$t\(/g,
-            quote: '"'
-          },
-          {
-            pattern: /`\$t\(/g,
-            quote: "`"
-          },
-          {
-            pattern: /\{\$t\(/g,
-            quote: "{"
-          },
-          {
-            pattern: /\[\$t\(/g,
-            quote: "["
-          }
-        ];
-        for (const { pattern, quote } of tPatterns) {
-          let match = pattern.exec(templateContent);
-          while (match !== null) {
-            const templateStart = templateMatch.index + templateMatch[0].indexOf(templateContent);
-            const start = templateStart + match.index;
-            const end = start + 4;
-            context.report({
-              fix(fixer) {
-                return fixer.replaceTextRange([start, end], `${quote}t(`);
-              },
-              loc: {
-                end: sourceCode.getLocFromIndex(end),
-                start: sourceCode.getLocFromIndex(start)
-              },
-              messageId: "useT"
-            });
-            match = pattern.exec(templateContent);
-          }
-        }
-      }
-    };
-  }
-};
-
 function sortObjectKeys(object) {
   if (Array.isArray(object)) {
     return object.map((item) => sortObjectKeys(item));
@@ -791,214 +611,135 @@ function sortObjectKeys(object) {
   if (object && typeof object === "object") {
     const sortedKeys = Object.keys(object).toSorted((key1, key2) => key1.localeCompare(key2));
     const result = {};
-    const obj = object;
+    const record = object;
     for (const key of sortedKeys) {
-      result[key] = sortObjectKeys(obj[key]);
+      result[key] = sortObjectKeys(record[key]);
     }
     return result;
   }
   return object;
 }
-const rule$6 = {
-  meta: {
-    docs: {
-      description: "Enforce consistent indentation and sorted keys in i18n blocks",
-      recommended: true
-    },
-    fixable: "whitespace",
-    messages: {
-      indentError: "Invalid indentation for i18n content. Expected {{expected}} spaces.",
-      invalidJson: "Invalid JSON in i18n block: {{error}}",
-      sortError: "Keys in i18n block should be sorted alphabetically."
+function checkSortAndIndent(context, parsed, rawContent, contentOffset) {
+  const sortedParsed = sortObjectKeys(parsed);
+  const formattedContent = `
+${JSON.stringify(sortedParsed, void 0, indentSpaces).replaceAll(/\n{2,}/g, "\n")}
+`;
+  if (formattedContent.trim() === rawContent.trim()) {
+    return;
+  }
+  const currentKeys = JSON.stringify(parsed, void 0, indentSpaces).trim();
+  const sortedKeys = JSON.stringify(sortedParsed, void 0, indentSpaces).trim();
+  context.report({
+    data: { expected: String(indentSpaces) },
+    fix: (fixer) => fixer.replaceTextRange([contentOffset, contentOffset + rawContent.length], formattedContent),
+    loc: {
+      end: context.sourceCode.getLocFromIndex(contentOffset + rawContent.length),
+      start: context.sourceCode.getLocFromIndex(contentOffset)
     },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
+    messageId: currentKeys === sortedKeys ? "indentError" : "sortError"
+  });
+}
+function checkUnusedStrings(context, parsed, source, content, contentOffset) {
+  if (!parsed.en) {
+    return;
+  }
+  const templateContent = templateRegex$1.exec(source)?.[1] ?? "";
+  const scriptContent = scriptRegex.exec(source)?.[1] ?? "";
+  for (const key of getAllKeys(parsed.en)) {
+    if (templateContent.includes(key) || scriptContent.includes(key)) {
+      continue;
     }
-    return {
-      Program() {
-        const source = context.sourceCode.getText();
-        const i18nRegex = /(<i18n\s+lang=["']json["']>)([\s\S]*?)<\/i18n>/i;
-        const i18nMatch = i18nRegex.exec(source);
-        if (i18nMatch) {
-          const startOffset = i18nMatch.index + i18nMatch[1].length;
-          const i18nContent = i18nMatch[2];
-          try {
-            const parsed = JSON.parse(i18nContent.trim());
-            const totalSpaces = 2;
-            const sortedParsed = sortObjectKeys(parsed);
-            const formattedContent = `
-${JSON.stringify(sortedParsed, void 0, totalSpaces).replaceAll(/\n{2,}/g, "\n")}
-`;
-            if (formattedContent.trim() !== i18nContent.trim()) {
-              const currentKeys = JSON.stringify(parsed, void 0, totalSpaces).trim();
-              const sortedKeys = JSON.stringify(sortedParsed, void 0, totalSpaces).trim();
-              context.report({
-                data: { expected: String(totalSpaces) },
-                fix(fixer) {
-                  return fixer.replaceTextRange(
-                    [startOffset, startOffset + i18nContent.length],
-                    formattedContent
-                  );
-                },
-                loc: {
-                  end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-                  start: context.sourceCode.getLocFromIndex(startOffset)
-                },
-                messageId: currentKeys === sortedKeys ? "indentError" : "sortError"
-              });
-            }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            context.report({
-              data: { error: errorMessage },
-              loc: {
-                end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-                start: context.sourceCode.getLocFromIndex(startOffset)
-              },
-              messageId: "invalidJson"
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-function getAllKeys(object, prefix = "") {
-  let keys = [];
-  for (const key in object) {
-    const newPrefix = prefix ? `${prefix}.${key}` : key;
-    if (typeof object[key] === "object" && object[key] !== null) {
-      keys = [...keys, ...getAllKeys(object[key], newPrefix)];
-    } else {
-      keys.push(newPrefix);
+    const keyMatch = new RegExp(String.raw`"${escapeRegExp(key)}"\s*:`, "g").exec(content);
+    if (keyMatch) {
+      const keyOffset = contentOffset + keyMatch.index;
+      context.report({
+        data: { key },
+        loc: {
+          end: context.sourceCode.getLocFromIndex(keyOffset + key.length + 2),
+          start: context.sourceCode.getLocFromIndex(keyOffset)
+        },
+        messageId: "unusedString"
+      });
     }
   }
-  return keys;
 }
-const rule$5 = {
+const rule$2 = {
+  defaultOptions: [{ locales: defaultLocales }],
   meta: {
-    docs: {
-      description: "Detect unused strings in the English locale",
-      recommended: true
-    },
+    docs: { description: "Format Vue i18n blocks: enforce valid/consistent locales, sorted keys, and no unused strings" },
+    fixable: "code",
     messages: {
+      indentError: "Invalid indentation for i18n content. Expected {{expected}} spaces.",
       invalidJson: "Invalid JSON in i18n block: {{error}}",
+      invalidLocale: "Invalid locale: {{locale}}. Allowed locales are: {{allowed}}",
+      missingLocale: "Missing required locale: {{locale}}",
+      missingTranslations: 'Missing translations in "{{locale}}" locale: {{missing}}',
+      sortError: "Keys in i18n block should be sorted alphabetically.",
       unusedString: 'Unused string in English locale: "{{key}}"'
     },
-    schema: [],
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          locales: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ],
     type: "problem"
   },
   create(context) {
     if (!context.filename.endsWith(".vue")) {
       return {};
     }
+    const locales = context.options[0]?.locales ?? defaultLocales;
     return {
       Program() {
         const source = context.sourceCode.getText();
-        const i18nRegex = /(<i18n\s+lang=["']json["']>)([\s\S]*?)<\/i18n>/i;
         const i18nMatch = i18nRegex.exec(source);
         if (!i18nMatch) {
           return;
         }
-        const startOffset = i18nMatch.index + i18nMatch[1].length;
-        const i18nContent = i18nMatch[2].trim();
+        const contentOffset = i18nMatch.index + i18nMatch[1].length;
+        const rawContent = i18nMatch[2];
+        const trimmedContent = rawContent.trim();
+        let parsed;
         try {
-          const parsed = JSON.parse(i18nContent);
-          if (!parsed.en) {
-            return;
-          }
-          const templateRegex = /<template>([\s\S]*)<\/template>/i;
-          const templateMatch = templateRegex.exec(source);
-          const templateContent = templateMatch ? templateMatch[1] : "";
-          const scriptRegex = /<script[^>]*>([\s\S]*?)<\/script>/i;
-          const scriptMatch = scriptRegex.exec(source);
-          const scriptContent = scriptMatch ? scriptMatch[1] : "";
-          const enKeys = getAllKeys(parsed.en);
-          for (const key of enKeys) {
-            const isUsed = templateContent.includes(key) || scriptContent.includes(key);
-            if (!isUsed) {
-              const keyMatch = new RegExp(String.raw`"${key}"\s*:`, "g").exec(i18nContent);
-              if (keyMatch) {
-                const keyOffset = startOffset + keyMatch.index;
-                context.report({
-                  data: { key },
-                  loc: {
-                    end: context.sourceCode.getLocFromIndex(keyOffset + key.length + 2),
-                    start: context.sourceCode.getLocFromIndex(keyOffset)
-                  },
-                  messageId: "unusedString"
-                });
-              }
-            }
-          }
+          parsed = JSON.parse(trimmedContent);
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
           context.report({
-            data: { error: errorMessage },
+            data: { error: error instanceof Error ? error.message : String(error) },
             loc: {
-              end: context.sourceCode.getLocFromIndex(startOffset + i18nContent.length),
-              start: context.sourceCode.getLocFromIndex(startOffset)
+              end: context.sourceCode.getLocFromIndex(contentOffset + rawContent.length),
+              start: context.sourceCode.getLocFromIndex(contentOffset)
             },
             messageId: "invalidJson"
           });
+          return;
         }
+        checkMissingLocales(context, parsed, locales, rawContent, contentOffset);
+        checkInvalidLocales(context, parsed, locales, rawContent, contentOffset);
+        checkMissingTranslations(context, parsed, locales, rawContent, contentOffset);
+        checkSortAndIndent(context, parsed, rawContent, contentOffset);
+        checkUnusedStrings(context, parsed, source, rawContent, contentOffset);
       }
     };
   }
 };
 
-const rule$4 = {
+const untypedEmitsRegex = /const\s+emit\s*=\s*defineEmits\(\[([^\]]+)\]\)/g;
+const rule$1 = {
   defaultOptions: [],
   meta: {
-    docs: { description: "Enforce multiline style for Vue computed properties" },
+    docs: { description: "Format Vue component scripts: enforce multiline computed properties and typed emits" },
     fixable: "code",
-    messages: { multilineComputed: "Computed properties should use explicit return with blocks" },
-    schema: [],
-    type: "layout"
-  },
-  create(context) {
-    return {
-      CallExpression(node) {
-        if (node.callee.type === distExports.AST_NODE_TYPES.Identifier && node.callee.name === "computed") {
-          const [argument] = node.arguments;
-          if (argument?.type === distExports.AST_NODE_TYPES.ArrowFunctionExpression) {
-            const sourceCode = context.sourceCode;
-            const functionBody = sourceCode.getText(argument.body);
-            if (!functionBody.startsWith("{")) {
-              const bodyText = functionBody.startsWith("(") && functionBody.endsWith(")") ? functionBody.slice(1, -1) : functionBody;
-              context.report({
-                fix(fixer) {
-                  return fixer.replaceText(
-                    argument.body,
-                    `{
-  return ${bodyText}
-}`
-                  );
-                },
-                messageId: "multilineComputed",
-                node
-              });
-            }
-          }
-        }
-      }
-    };
-  }
-};
-
-const rule$3 = {
-  meta: {
-    docs: {
-      description: "Enforce typed emits in Vue components",
-      recommended: true
+    messages: {
+      multilineComputed: "Computed properties should use explicit return with blocks",
+      untypedEmits: "Use typed emits instead of untyped emits"
     },
-    fixable: "code",
-    messages: { untypedEmits: "Use typed emits instead of untyped emits" },
     schema: [],
     type: "problem"
   },
@@ -1007,9 +748,32 @@ const rule$3 = {
       return {};
     }
     return {
+      // Rewrite computed(() => expr) into an explicit return block.
+      CallExpression(node) {
+        if (node.callee.type !== distExports.AST_NODE_TYPES.Identifier || node.callee.name !== "computed") {
+          return;
+        }
+        const [argument] = node.arguments;
+        if (argument?.type !== distExports.AST_NODE_TYPES.ArrowFunctionExpression) {
+          return;
+        }
+        const functionBody = context.sourceCode.getText(argument.body);
+        if (functionBody.startsWith("{")) {
+          return;
+        }
+        const bodyText = functionBody.startsWith("(") && functionBody.endsWith(")") ? functionBody.slice(1, -1) : functionBody;
+        context.report({
+          fix: (fixer) => fixer.replaceText(argument.body, `{
+  return ${bodyText}
+}`),
+          messageId: "multilineComputed",
+          node
+        });
+      },
+      // Rewrite array-syntax defineEmits([...]) into the typed generic form.
       Program(node) {
         const source = context.sourceCode.getText();
-        const untypedEmitsRegex = /const\s+emit\s*=\s*defineEmits\(\[([^\]]+)\]\)/g;
+        untypedEmitsRegex.lastIndex = 0;
         let match = untypedEmitsRegex.exec(source);
         while (match !== null) {
           const [fullMatch, eventsString] = match;
@@ -1020,12 +784,7 @@ const rule$3 = {
 ${typedEvents}
 }>()`;
           context.report({
-            fix: (fixer) => {
-              return fixer.replaceTextRange(
-                [matchIndex, matchIndex + fullMatch.length],
-                typedEmits
-              );
-            },
+            fix: (fixer) => fixer.replaceTextRange([matchIndex, matchIndex + fullMatch.length], typedEmits),
             loc: {
               end: context.sourceCode.getLocFromIndex(matchIndex + fullMatch.length),
               start: context.sourceCode.getLocFromIndex(matchIndex)
@@ -1040,38 +799,42 @@ ${typedEvents}
   }
 };
 
-const rule$2 = {
-  meta: {
-    docs: {
-      description: "enforce order of compiler macros (`defineProps`, `defineEmits`, etc.)",
-      recommended: true
-    },
-    fixable: "code",
-    hasSuggestions: true,
-    messages: {
-      defineExposeNotTheLast: "`defineExpose` should be the last statement in `<script setup>`.",
-      macrosNotOnTop: "{{macro}} should be the first statement in `<script setup>` (after any potential import statements or type definitions).",
-      putExposeAtTheLast: "Put `defineExpose` as the last statement in `<script setup>`."
-    },
-    schema: [],
-    type: "problem"
+const templateRegex = /<template>([\s\S]*)<\/template>/i;
+const templateTagLength = "<template>".length;
+const propsPrefixRegex = /\$?props\.(\w+)/g;
+const trueAttributeRegex = /(?<![\w-]):?(?!aria-)([a-z0-9-]+)="true"/gi;
+const dollarTPatterns = [
+  {
+    pattern: / \$t\(/g,
+    prefix: " "
   },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {};
+  {
+    pattern: /"\$t\(/g,
+    prefix: '"'
+  },
+  {
+    pattern: /`\$t\(/g,
+    prefix: "`"
+  },
+  {
+    pattern: /\{\$t\(/g,
+    prefix: "{"
+  },
+  {
+    pattern: /\[\$t\(/g,
+    prefix: "["
   }
-};
-
-const rule$1 = {
+];
+const rule = {
+  defaultOptions: [],
   meta: {
-    docs: {
-      description: "Prevent unnecessary props. and $props. prefixes in Vue templates",
-      recommended: true
-    },
+    docs: { description: 'Format Vue templates: strip unnecessary props/$props prefixes, redundant ="true" attributes (except aria- attributes), and enforce t() over $t()' },
     fixable: "code",
-    messages: { noPropsPrefix: "Unnecessary props/$props prefix in template. Props are automatically available in template scope." },
+    messages: {
+      noPropsPrefix: "Unnecessary props/$props prefix in template. Props are automatically available in template scope.",
+      removeTrueAttribute: 'Unnecessary ="true" attribute. Use the attribute name directly instead.',
+      useT: "Use t() instead of $t() in Vue templates as it does not work with <i18n> tags."
+    },
     schema: [],
     type: "problem"
   },
@@ -1080,31 +843,23 @@ const rule$1 = {
       return {};
     }
     return {
-      CallExpression(node) {
-        if (node.callee.type !== "Identifier" || node.callee.name !== "defineProps") {
-          return;
-        }
+      Program() {
         const sourceCode = context.sourceCode;
         const source = sourceCode.getText();
-        const templateRegex = /<template>([\s\S]*)<\/template>/i;
         const templateMatch = templateRegex.exec(source);
         if (!templateMatch) {
           return;
         }
         const templateContent = templateMatch[1];
-        const propsPrefixRegex = /\$?props\.(\w+)/g;
+        const templateStartIndex = templateMatch.index + templateTagLength;
+        propsPrefixRegex.lastIndex = 0;
         let prefixMatch = propsPrefixRegex.exec(templateContent);
         while (prefixMatch !== null) {
           const propName = prefixMatch[1];
           const fullMatch = prefixMatch[0];
-          const matchIndex = templateMatch.index + 10 + (prefixMatch.index ?? 0);
+          const matchIndex = templateStartIndex + prefixMatch.index;
           context.report({
-            fix: (fixer) => {
-              return fixer.replaceTextRange(
-                [matchIndex, matchIndex + fullMatch.length],
-                propName
-              );
-            },
+            fix: (fixer) => fixer.replaceTextRange([matchIndex, matchIndex + fullMatch.length], propName),
             loc: {
               end: sourceCode.getLocFromIndex(matchIndex + fullMatch.length),
               start: sourceCode.getLocFromIndex(matchIndex)
@@ -1113,38 +868,7 @@ const rule$1 = {
           });
           prefixMatch = propsPrefixRegex.exec(templateContent);
         }
-      }
-    };
-  }
-};
-
-const rule = {
-  meta: {
-    docs: {
-      description: 'Remove unnecessary ="true" attributes in Vue templates, except for aria- attributes',
-      recommended: true
-    },
-    fixable: "code",
-    messages: { removeTrueAttribute: 'Unnecessary ="true" attribute. Use the attribute name directly instead.' },
-    schema: [],
-    type: "problem"
-  },
-  create(context) {
-    if (!context.filename.endsWith(".vue")) {
-      return {};
-    }
-    return {
-      Program() {
-        const sourceCode = context.sourceCode;
-        const source = sourceCode.getText();
-        const templateRegex = /<template>([\s\S]*)<\/template>/i;
-        const templateMatch = templateRegex.exec(source);
-        if (!templateMatch) {
-          return;
-        }
-        const templateContent = templateMatch[1];
-        const templateStartIndex = templateMatch.index + 10;
-        const trueAttributeRegex = /(?:^|\s):?(?!aria-)([a-zA-Z0-9-]+)="true"/g;
+        trueAttributeRegex.lastIndex = 0;
         let trueAttributeMatch = trueAttributeRegex.exec(templateContent);
         while (trueAttributeMatch !== null) {
           const fullMatch = trueAttributeMatch[0];
@@ -1156,12 +880,7 @@ const rule = {
             continue;
           }
           context.report({
-            fix: (fixer) => {
-              return fixer.replaceTextRange(
-                [matchIndex, matchIndex + fullMatch.length],
-                ` ${attributeName}`
-              );
-            },
+            fix: (fixer) => fixer.replaceTextRange([matchIndex, matchIndex + fullMatch.length], attributeName),
             loc: {
               end: sourceCode.getLocFromIndex(matchIndex + fullMatch.length),
               start: sourceCode.getLocFromIndex(matchIndex)
@@ -1170,6 +889,23 @@ const rule = {
           });
           trueAttributeMatch = trueAttributeRegex.exec(templateContent);
         }
+        for (const { pattern, prefix } of dollarTPatterns) {
+          pattern.lastIndex = 0;
+          let dollarTMatch = pattern.exec(templateContent);
+          while (dollarTMatch !== null) {
+            const start = templateStartIndex + dollarTMatch.index;
+            const end = start + 4;
+            context.report({
+              fix: (fixer) => fixer.replaceTextRange([start, end], `${prefix}t(`),
+              loc: {
+                end: sourceCode.getLocFromIndex(end),
+                start: sourceCode.getLocFromIndex(start)
+              },
+              messageId: "useT"
+            });
+            dollarTMatch = pattern.exec(templateContent);
+          }
+        }
       }
     };
   }
@@ -1177,19 +913,11 @@ const rule = {
 
 const index = {
   rules: {
-    "ts-multiline-ternary": rule$c,
-    "ts-multiline-union": rule$b,
-    "ts-padding-statements": rule$a,
-    "ts-sort-tests": rule$9,
-    "vue-i18n-consistent-locales": rule$8,
-    "vue-i18n-consistent-t": rule$7,
-    "vue-i18n-sort-keys": rule$6,
-    "vue-i18n-unused-strings": rule$5,
-    "vue-script-format-computed": rule$4,
-    "vue-script-format-emits": rule$3,
-    "vue-script-order": rule$2,
-    "vue-template-format-props": rule$1,
-    "vue-template-remove-true-attributes": rule
+    "ts-format-layout": rule$4,
+    "ts-format-tests": rule$3,
+    "vue-format-i18n": rule$2,
+    "vue-format-script": rule$1,
+    "vue-format-template": rule
   }
 };