@saasmakers/eslint 0.1.3 → 0.1.4

package/dist/eslint.config.cjs

@@ -183,6 +183,19 @@ const eslint_config = antfu__default(
       "saasmakers/ts-multiline-ternary": "error",
       "saasmakers/ts-multiline-union": "error",
       "saasmakers/ts-sort-tests": "error",
+      "saasmakers/vue-i18n-consistent-locales": [
+        "error",
+        {
+          locales: [
+            "en",
+            "fr",
+            "ja"
+          ]
+        }
+      ],
+      "saasmakers/vue-i18n-consistent-t": "error",
+      "saasmakers/vue-i18n-sort-keys": "error",
+      "saasmakers/vue-i18n-unused-strings": "error",
       "sort-imports": "off",
       "ts/ban-ts-comment": "off",
       "ts/ban-ts-ignore": "off",

package/dist/eslint.config.d.cts

@@ -175,6 +175,19 @@ var eslint_config = antfu(
       "saasmakers/ts-multiline-ternary": "error",
       "saasmakers/ts-multiline-union": "error",
       "saasmakers/ts-sort-tests": "error",
+      "saasmakers/vue-i18n-consistent-locales": [
+        "error",
+        {
+          locales: [
+            "en",
+            "fr",
+            "ja"
+          ]
+        }
+      ],
+      "saasmakers/vue-i18n-consistent-t": "error",
+      "saasmakers/vue-i18n-sort-keys": "error",
+      "saasmakers/vue-i18n-unused-strings": "error",
       "sort-imports": "off",
       "ts/ban-ts-comment": "off",
       "ts/ban-ts-ignore": "off",

package/dist/eslint.config.d.mts

@@ -175,6 +175,19 @@ var eslint_config = antfu(
       "saasmakers/ts-multiline-ternary": "error",
       "saasmakers/ts-multiline-union": "error",
       "saasmakers/ts-sort-tests": "error",
+      "saasmakers/vue-i18n-consistent-locales": [
+        "error",
+        {
+          locales: [
+            "en",
+            "fr",
+            "ja"
+          ]
+        }
+      ],
+      "saasmakers/vue-i18n-consistent-t": "error",
+      "saasmakers/vue-i18n-sort-keys": "error",
+      "saasmakers/vue-i18n-unused-strings": "error",
       "sort-imports": "off",
       "ts/ban-ts-comment": "off",
       "ts/ban-ts-ignore": "off",

package/dist/eslint.config.d.ts

@@ -175,6 +175,19 @@ var eslint_config = antfu(
       "saasmakers/ts-multiline-ternary": "error",
       "saasmakers/ts-multiline-union": "error",
       "saasmakers/ts-sort-tests": "error",
+      "saasmakers/vue-i18n-consistent-locales": [
+        "error",
+        {
+          locales: [
+            "en",
+            "fr",
+            "ja"
+          ]
+        }
+      ],
+      "saasmakers/vue-i18n-consistent-t": "error",
+      "saasmakers/vue-i18n-sort-keys": "error",
+      "saasmakers/vue-i18n-unused-strings": "error",
       "sort-imports": "off",
       "ts/ban-ts-comment": "off",
       "ts/ban-ts-ignore": "off",

package/dist/eslint.config.mjs

@@ -175,6 +175,19 @@ const eslint_config = antfu(
       "saasmakers/ts-multiline-ternary": "error",
       "saasmakers/ts-multiline-union": "error",
       "saasmakers/ts-sort-tests": "error",
+      "saasmakers/vue-i18n-consistent-locales": [
+        "error",
+        {
+          locales: [
+            "en",
+            "fr",
+            "ja"
+          ]
+        }
+      ],
+      "saasmakers/vue-i18n-consistent-t": "error",
+      "saasmakers/vue-i18n-sort-keys": "error",
+      "saasmakers/vue-i18n-unused-strings": "error",
       "sort-imports": "off",
       "ts/ban-ts-comment": "off",
       "ts/ban-ts-ignore": "off",

package/dist/index.cjs

@@ -14084,7 +14084,7 @@ function requireDist () {
 
 var distExports = requireDist();
 
-const rule$2 = {
+const rule$6 = {
   meta: {
     docs: {
       category: "Stylistic Issues",
@@ -14147,7 +14147,7 @@ const rule$2 = {
   }
 };
 
-const rule$1 = {
+const rule$5 = {
   meta: {
     docs: {
       category: "Stylistic Issues",
@@ -14213,7 +14213,7 @@ const rule$1 = {
   }
 };
 
-const rule = {
+const rule$4 = {
   meta: {
     docs: {
       category: "Best Practices",
@@ -14328,15 +14328,382 @@ const rule = {
   }
 };
 
+const rule$3 = {
+  meta: {
+    docs: {
+      category: "Possible Errors",
+      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 i18nMatch = source.match(/(<i18n\s+lang=["']json["']>)([\s\S]*?)(<\/i18n>)/i);
+        if (i18nMatch) {
+          const startOffset = i18nMatch.index + i18nMatch[1].length;
+          const i18nContent = i18nMatch[2].trim();
+          try {
+            const parsed = JSON.parse(i18nContent);
+            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)
+                  },
+                  messageId: "missingLocale"
+                });
+              }
+            }
+            for (const locale of Object.keys(parsed)) {
+              if (!locales.includes(locale)) {
+                const localeMatch = new RegExp(`"${locale}"\\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"
+                  });
+                }
+              }
+            }
+            const allKeys = /* @__PURE__ */ new Set();
+            for (const locale of locales) {
+              if (parsed[locale]) {
+                const keys = getAllKeys(parsed[locale]);
+                keys.forEach((key) => allKeys.add(key));
+              }
+            }
+            for (const locale of locales) {
+              if (parsed[locale]) {
+                const localeKeys = getAllKeys(parsed[locale]);
+                const missingKeys = [...allKeys].filter((key) => !localeKeys.includes(key));
+                if (missingKeys.length > 0) {
+                  const localeMatch = new RegExp(`"${locale}"\\s*:\\s*{`, "g").exec(i18nContent);
+                  if (localeMatch) {
+                    const localeOffset = startOffset + localeMatch.index;
+                    context.report({
+                      data: {
+                        locale,
+                        missing: missingKeys.join(", ")
+                      },
+                      loc: {
+                        end: context.sourceCode.getLocFromIndex(localeOffset + locale.length + 2),
+                        start: context.sourceCode.getLocFromIndex(localeOffset)
+                      },
+                      messageId: "missingTranslations"
+                    });
+                  }
+                }
+              }
+            }
+          } 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);
+            }
+          }
+          return keys;
+        }
+      }
+    };
+  }
+};
+
+const rule$2 = {
+  meta: {
+    docs: {
+      category: "Best Practices",
+      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 templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
+        if (!templateMatch || templateMatch.index === void 0) {
+          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;
+          while ((match = pattern.exec(templateContent)) !== 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"
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+const rule$1 = {
+  meta: {
+    docs: {
+      category: "Best Practices",
+      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."
+    },
+    schema: [],
+    type: "problem"
+  },
+  create(context) {
+    if (!context.filename.endsWith(".vue")) {
+      return {};
+    }
+    function sortObjectKeys(object) {
+      if (Array.isArray(object)) {
+        return object.map(sortObjectKeys);
+      }
+      if (object && typeof object === "object") {
+        const sortedKeys = Object.keys(object).sort();
+        const result = {};
+        const obj = object;
+        for (const key of sortedKeys) {
+          result[key] = sortObjectKeys(obj[key]);
+        }
+        return result;
+      }
+      return object;
+    }
+    return {
+      Program() {
+        const source = context.sourceCode.getText();
+        const i18nMatch = source.match(/(<i18n\s+lang=["']json["']>)([\s\S]*?)(<\/i18n>)/i);
+        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, null, totalSpaces).replace(/\n\n+/g, "\n")}
+`;
+            if (formattedContent.trim() !== i18nContent.trim()) {
+              const currentKeys = JSON.stringify(parsed, null, totalSpaces).trim();
+              const sortedKeys = JSON.stringify(sortedParsed, null, 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 ? "sortError" : "indentError"
+              });
+            }
+          } 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 = {
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Detect unused strings in the English locale",
+      recommended: true
+    },
+    messages: {
+      invalidJson: "Invalid JSON in i18n block: {{error}}",
+      unusedString: 'Unused string in English locale: "{{key}}"'
+    },
+    schema: [],
+    type: "problem"
+  },
+  create(context) {
+    if (!context.filename.endsWith(".vue")) {
+      return {};
+    }
+    return {
+      Program() {
+        const source = context.sourceCode.getText();
+        const i18nMatch = source.match(/(<i18n\s+lang=["']json["']>)([\s\S]*?)(<\/i18n>)/i);
+        if (!i18nMatch) {
+          return;
+        }
+        const startOffset = i18nMatch.index + i18nMatch[1].length;
+        const i18nContent = i18nMatch[2].trim();
+        try {
+          const parsed = JSON.parse(i18nContent);
+          if (!parsed.en) {
+            return;
+          }
+          const templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
+          const templateContent = templateMatch ? templateMatch[1] : "";
+          const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+          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(`"${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"
+                });
+              }
+            }
+          }
+        } 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);
+        }
+      }
+      return keys;
+    }
+  }
+};
+
 const index = {
   rules: {
-    "ts-multiline-ternary": rule$2,
-    "ts-multiline-union": rule$1,
-    "ts-sort-tests": rule
-    // 'vue-i18n-consistent-locales': vueI18nConsistentLocales,
-    // 'vue-i18n-consistent-t': vueI18nConsistentT,
-    // 'vue-i18n-sort-keys': vueI18nSortKeys,
-    // 'vue-i18n-unused-strings': vueI18nUnusedStrings,
+    "ts-multiline-ternary": rule$6,
+    "ts-multiline-union": rule$5,
+    "ts-sort-tests": rule$4,
+    "vue-i18n-consistent-locales": rule$3,
+    "vue-i18n-consistent-t": rule$2,
+    "vue-i18n-sort-keys": rule$1,
+    "vue-i18n-unused-strings": rule
     // 'vue-script-format-computed': vueScriptFormatComputed,
     // 'vue-script-format-emits': vueScriptFormatEmits,
     // 'vue-script-format-props': vueScriptFormatProps,

package/dist/index.d.cts

@@ -5,6 +5,10 @@ declare const _default: {
         'ts-multiline-ternary': eslint.Rule.RuleModule;
         'ts-multiline-union': eslint.Rule.RuleModule;
         'ts-sort-tests': eslint.Rule.RuleModule;
+        'vue-i18n-consistent-locales': eslint.Rule.RuleModule;
+        'vue-i18n-consistent-t': eslint.Rule.RuleModule;
+        'vue-i18n-sort-keys': eslint.Rule.RuleModule;
+        'vue-i18n-unused-strings': eslint.Rule.RuleModule;
     };
 };
 

package/dist/index.d.mts

@@ -5,6 +5,10 @@ declare const _default: {
         'ts-multiline-ternary': eslint.Rule.RuleModule;
         'ts-multiline-union': eslint.Rule.RuleModule;
         'ts-sort-tests': eslint.Rule.RuleModule;
+        'vue-i18n-consistent-locales': eslint.Rule.RuleModule;
+        'vue-i18n-consistent-t': eslint.Rule.RuleModule;
+        'vue-i18n-sort-keys': eslint.Rule.RuleModule;
+        'vue-i18n-unused-strings': eslint.Rule.RuleModule;
     };
 };
 

package/dist/index.d.ts

@@ -5,6 +5,10 @@ declare const _default: {
         'ts-multiline-ternary': eslint.Rule.RuleModule;
         'ts-multiline-union': eslint.Rule.RuleModule;
         'ts-sort-tests': eslint.Rule.RuleModule;
+        'vue-i18n-consistent-locales': eslint.Rule.RuleModule;
+        'vue-i18n-consistent-t': eslint.Rule.RuleModule;
+        'vue-i18n-sort-keys': eslint.Rule.RuleModule;
+        'vue-i18n-unused-strings': eslint.Rule.RuleModule;
     };
 };
 

package/dist/index.mjs

@@ -14077,7 +14077,7 @@ function requireDist () {
 
 var distExports = requireDist();
 
-const rule$2 = {
+const rule$6 = {
   meta: {
     docs: {
       category: "Stylistic Issues",
@@ -14140,7 +14140,7 @@ const rule$2 = {
   }
 };
 
-const rule$1 = {
+const rule$5 = {
   meta: {
     docs: {
       category: "Stylistic Issues",
@@ -14206,7 +14206,7 @@ const rule$1 = {
   }
 };
 
-const rule = {
+const rule$4 = {
   meta: {
     docs: {
       category: "Best Practices",
@@ -14321,15 +14321,382 @@ const rule = {
   }
 };
 
+const rule$3 = {
+  meta: {
+    docs: {
+      category: "Possible Errors",
+      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 i18nMatch = source.match(/(<i18n\s+lang=["']json["']>)([\s\S]*?)(<\/i18n>)/i);
+        if (i18nMatch) {
+          const startOffset = i18nMatch.index + i18nMatch[1].length;
+          const i18nContent = i18nMatch[2].trim();
+          try {
+            const parsed = JSON.parse(i18nContent);
+            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)
+                  },
+                  messageId: "missingLocale"
+                });
+              }
+            }
+            for (const locale of Object.keys(parsed)) {
+              if (!locales.includes(locale)) {
+                const localeMatch = new RegExp(`"${locale}"\\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"
+                  });
+                }
+              }
+            }
+            const allKeys = /* @__PURE__ */ new Set();
+            for (const locale of locales) {
+              if (parsed[locale]) {
+                const keys = getAllKeys(parsed[locale]);
+                keys.forEach((key) => allKeys.add(key));
+              }
+            }
+            for (const locale of locales) {
+              if (parsed[locale]) {
+                const localeKeys = getAllKeys(parsed[locale]);
+                const missingKeys = [...allKeys].filter((key) => !localeKeys.includes(key));
+                if (missingKeys.length > 0) {
+                  const localeMatch = new RegExp(`"${locale}"\\s*:\\s*{`, "g").exec(i18nContent);
+                  if (localeMatch) {
+                    const localeOffset = startOffset + localeMatch.index;
+                    context.report({
+                      data: {
+                        locale,
+                        missing: missingKeys.join(", ")
+                      },
+                      loc: {
+                        end: context.sourceCode.getLocFromIndex(localeOffset + locale.length + 2),
+                        start: context.sourceCode.getLocFromIndex(localeOffset)
+                      },
+                      messageId: "missingTranslations"
+                    });
+                  }
+                }
+              }
+            }
+          } 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);
+            }
+          }
+          return keys;
+        }
+      }
+    };
+  }
+};
+
+const rule$2 = {
+  meta: {
+    docs: {
+      category: "Best Practices",
+      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 templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
+        if (!templateMatch || templateMatch.index === void 0) {
+          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;
+          while ((match = pattern.exec(templateContent)) !== 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"
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+const rule$1 = {
+  meta: {
+    docs: {
+      category: "Best Practices",
+      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."
+    },
+    schema: [],
+    type: "problem"
+  },
+  create(context) {
+    if (!context.filename.endsWith(".vue")) {
+      return {};
+    }
+    function sortObjectKeys(object) {
+      if (Array.isArray(object)) {
+        return object.map(sortObjectKeys);
+      }
+      if (object && typeof object === "object") {
+        const sortedKeys = Object.keys(object).sort();
+        const result = {};
+        const obj = object;
+        for (const key of sortedKeys) {
+          result[key] = sortObjectKeys(obj[key]);
+        }
+        return result;
+      }
+      return object;
+    }
+    return {
+      Program() {
+        const source = context.sourceCode.getText();
+        const i18nMatch = source.match(/(<i18n\s+lang=["']json["']>)([\s\S]*?)(<\/i18n>)/i);
+        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, null, totalSpaces).replace(/\n\n+/g, "\n")}
+`;
+            if (formattedContent.trim() !== i18nContent.trim()) {
+              const currentKeys = JSON.stringify(parsed, null, totalSpaces).trim();
+              const sortedKeys = JSON.stringify(sortedParsed, null, 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 ? "sortError" : "indentError"
+              });
+            }
+          } 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 = {
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Detect unused strings in the English locale",
+      recommended: true
+    },
+    messages: {
+      invalidJson: "Invalid JSON in i18n block: {{error}}",
+      unusedString: 'Unused string in English locale: "{{key}}"'
+    },
+    schema: [],
+    type: "problem"
+  },
+  create(context) {
+    if (!context.filename.endsWith(".vue")) {
+      return {};
+    }
+    return {
+      Program() {
+        const source = context.sourceCode.getText();
+        const i18nMatch = source.match(/(<i18n\s+lang=["']json["']>)([\s\S]*?)(<\/i18n>)/i);
+        if (!i18nMatch) {
+          return;
+        }
+        const startOffset = i18nMatch.index + i18nMatch[1].length;
+        const i18nContent = i18nMatch[2].trim();
+        try {
+          const parsed = JSON.parse(i18nContent);
+          if (!parsed.en) {
+            return;
+          }
+          const templateMatch = source.match(/<template>([\s\S]*)<\/template>/i);
+          const templateContent = templateMatch ? templateMatch[1] : "";
+          const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+          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(`"${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"
+                });
+              }
+            }
+          }
+        } 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);
+        }
+      }
+      return keys;
+    }
+  }
+};
+
 const index = {
   rules: {
-    "ts-multiline-ternary": rule$2,
-    "ts-multiline-union": rule$1,
-    "ts-sort-tests": rule
-    // 'vue-i18n-consistent-locales': vueI18nConsistentLocales,
-    // 'vue-i18n-consistent-t': vueI18nConsistentT,
-    // 'vue-i18n-sort-keys': vueI18nSortKeys,
-    // 'vue-i18n-unused-strings': vueI18nUnusedStrings,
+    "ts-multiline-ternary": rule$6,
+    "ts-multiline-union": rule$5,
+    "ts-sort-tests": rule$4,
+    "vue-i18n-consistent-locales": rule$3,
+    "vue-i18n-consistent-t": rule$2,
+    "vue-i18n-sort-keys": rule$1,
+    "vue-i18n-unused-strings": rule
     // 'vue-script-format-computed': vueScriptFormatComputed,
     // 'vue-script-format-emits': vueScriptFormatEmits,
     // 'vue-script-format-props': vueScriptFormatProps,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@saasmakers/eslint",
   "type": "module",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "private": false,
   "description": "Shared ESLint config for SaaS Makers projects",
   "license": "MIT",