i18n-smell-detector 0.1.1 → 0.3.0

package/README.md

@@ -6,11 +6,12 @@
 
 Find locale values copied from the base locale.
 
-`i18n-smell-detector` checks localization files for keys whose translated value is identical to the base locale. This can help catch entries that were copied as placeholders and never translated.
+`i18n-smell-detector` checks localization files for keys whose translated value is identical to the base locale. It can also scan Vue templates for hardcoded user-visible strings.
 
 ## Features
 
 - Detect values that are identical to the base locale
+- Detect hardcoded strings in Vue template text and selected attributes
 - Ignore expected matches by key or value
 - Classify findings as `high`, `medium`, `low`, or `ignored`
 - Output results as console text, JSON, or Markdown
@@ -28,6 +29,7 @@ Run the check:
 
 ```bash
 npx i18n-smell-detector check-identical --config i18n-smell.config.mjs
+npx i18n-smell-detector check-hardcoded --config i18n-smell.config.mjs
 ```
 
 Output formats:
@@ -36,6 +38,7 @@ Output formats:
 npx i18n-smell-detector check-identical --format console
 npx i18n-smell-detector check-identical --format json
 npx i18n-smell-detector check-identical --format markdown
+npx i18n-smell-detector check-hardcoded --format json
 ```
 
 ## CI usage
@@ -59,6 +62,10 @@ Create `i18n-smell.config.mjs`:
 ```js
 export default {
   baseLocale: 'en',
+  source: [
+    'src/**/*.vue'
+  ],
+
   locales: {
     en: './src/locales/en.json',
     zh: './src/locales/zh.json',
@@ -67,7 +74,7 @@ export default {
 
   allowIdenticalKeys: [
     'brand.*',
-    'protocol.*',
+    /^protocol\./,
     'common.ok',
     'common.id'
   ],
@@ -75,12 +82,37 @@ export default {
   allowIdenticalValues: [
     'OK',
     'ID',
-    'HTTP',
+    /^HTTP\/\d(\.\d)?$/,
     'API',
     'GET',
     'POST'
   ],
 
+  placeholderPatterns: [
+    '\\{[^}]+\\}',
+    '\\{\\{[^}]+\\}\\}',
+    '%[sdif]',
+    '%\\([^)]+\\)[sdif]',
+    '\\$\\d+'
+  ],
+
+  ignoreCodeLike: true,
+  hardcoded: {
+    vueAttributes: [
+      'placeholder',
+      'title',
+      'alt',
+      'aria-label',
+      'aria-description'
+    ],
+    ignoreValues: [
+      'OK',
+      'ID'
+    ],
+    ignorePatterns: [
+      '^v\\d+$'
+    ]
+  },
   ignoreSameLanguageFamily: true,
   trimWhitespace: true,
   ignoreCase: false,
@@ -94,9 +126,15 @@ export default {
 | Option | Type | Default | Description |
 |---|---|---:|---|
 | `baseLocale` | `string` | `'en'` | Locale used as the comparison source. It must also be listed in `locales`. |
+| `source` | `string[]` | `['src/**/*.vue']` | Source globs used by `check-hardcoded`. `node_modules` is ignored. |
 | `locales` | `Record<string, string>` | `{}` | Map of locale codes to JSON locale file paths. Relative paths are resolved from the config file directory. |
-| `allowIdenticalKeys` | `string[]` | `[]` | Key patterns that are allowed to match the base locale. Supports `*` wildcards, for example `brand.*`. |
-| `allowIdenticalValues` | `string[]` | `[]` | Exact values that are allowed to match the base locale, for example `OK`, `API`, or `GET`. |
+| `allowIdenticalKeys` | `(string \| RegExp)[]` | `[]` | Key rules that are allowed to match the base locale. String rules support `*` wildcards, for example `brand.*`. `RegExp` rules are tested against the flattened key. |
+| `allowIdenticalValues` | `(string \| RegExp)[]` | `[]` | Value rules that are allowed to match the base locale. String rules are exact matches, for example `OK`, `API`, or `GET`. `RegExp` rules are tested against the full value. |
+| `placeholderPatterns` | `(string \| RegExp)[]` | `{...}` and `{{...}}` patterns | Placeholder patterns ignored when the whole value is only placeholders and whitespace. String entries must be valid regular expression sources. |
+| `ignoreCodeLike` | `boolean` | `true` | Ignore built-in code-like values such as paths, colors, acronyms, and identifiers. Set to `false` to report them. |
+| `hardcoded.vueAttributes` | `string[]` | `placeholder`, `title`, `alt`, `aria-label`, `aria-description` | Static Vue attributes checked by `check-hardcoded`. Dynamic bindings such as `:placeholder` are ignored. |
+| `hardcoded.ignoreValues` | `(string \| RegExp)[]` | `[]` | Exact values or regular expressions ignored by `check-hardcoded`. |
+| `hardcoded.ignorePatterns` | `(string \| RegExp)[]` | `[]` | Regular expression patterns ignored by `check-hardcoded`. String entries are compiled as regular expressions. |
 | `failOn` | `'high' \| 'medium' \| 'low' \| 'none'` | `'high'` | Lowest severity that makes the CLI exit with code `1`. Use `none` to report without failing. |
 | `trimWhitespace` | `boolean` | `true` | Trim leading and trailing whitespace before comparing values. |
 | `ignoreCase` | `boolean` | `false` | Compare values case-insensitively when set to `true`. |
@@ -124,10 +162,16 @@ MEDIUM ja.form.search
 
 ## JSON output
 
-`--format json` prints an object with an `issues` array:
+`--format json` prints an object with a `summary` and an `issues` array:
 
 ```json
 {
+  "summary": {
+    "high": 1,
+    "medium": 0,
+    "low": 0,
+    "ignored": 16
+  },
   "issues": [
     {
       "key": "home.welcome",
@@ -143,6 +187,8 @@ MEDIUM ja.form.search
 
 Fields:
 
+Summary counts include all findings, including ignored findings that may be omitted from the visible `issues` array.
+
 | Field | Type | Description |
 |---|---|---|
 | `key` | `string` | Flattened locale key, such as `settings.profile.title`. |
@@ -154,6 +200,47 @@ Fields:
 
 Ignored issues are omitted by default. Pass `--include-ignored` to include them in JSON, console, or Markdown output.
 
+## Hardcoded string output
+
+`check-hardcoded` reports Vue template text and static user-visible attributes:
+
+```txt
+i18n-smell-detector: hardcoded strings
+high=1 medium=1 low=0 ignored=4
+
+HIGH src/components/UserPanel.vue:12:15
+  value: "Profile settings"
+  reason: static template text
+
+MEDIUM src/components/SearchInput.vue:8:23
+  value: "Search"
+  reason: static placeholder attribute
+```
+
+JSON output includes source locations:
+
+```json
+{
+  "summary": {
+    "high": 1,
+    "medium": 1,
+    "low": 0,
+    "ignored": 4
+  },
+  "issues": [
+    {
+      "file": "src/components/UserPanel.vue",
+      "line": 12,
+      "column": 15,
+      "value": "Profile settings",
+      "severity": "high",
+      "reason": "static template text",
+      "kind": "vue-text"
+    }
+  ]
+}
+```
+
 ## Exit codes
 
 | Code | Meaning |
@@ -169,12 +256,14 @@ Ignored issues are omitted by default. Pass `--include-ignored` to include them
 | Key matches `allowIdenticalKeys` | ignored |
 | Value matches `allowIdenticalValues` | ignored |
 | Same language family, such as `en` and `en-GB` | ignored |
-| URL, path, color, or code-like value | ignored |
 | Placeholder-only value, such as `{count}` | ignored |
+| URL, path, color, or code-like value | ignored by default |
 | Short common label | low |
 | Single English word | medium |
 | English phrase | high |
 
+For `check-hardcoded`, sentence-like template text and static attributes are `high`, single words are `medium`, short common labels are `low`, and configured or non-user-facing values are `ignored`.
+
 ## False positive tuning
 
 Identical text is sometimes intentional. Start by running the detector in reporting mode, then allow known names, protocol terms, short labels, and other strings that should stay the same across languages.
@@ -189,13 +278,19 @@ export default {
   allowIdenticalKeys: [
     'brand.*',
     'legal.name',
-    'protocol.*'
+    /^protocol\./
   ],
   allowIdenticalValues: [
     'OK',
     'ID',
     'API',
-    'HTTPS'
+    /^HTTP\/\d(\.\d)?$/
+  ],
+  placeholderPatterns: [
+    '\\{[^}]+\\}',
+    '\\{\\{[^}]+\\}\\}',
+    '%[sdif]',
+    '%\\([^)]+\\)[sdif]'
   ],
   failOn: 'high'
 };
@@ -204,10 +299,20 @@ export default {
 Useful tuning patterns:
 
 - Use `allowIdenticalKeys` for groups of expected identical values, such as names, legal labels, and protocol keys.
-- Use `allowIdenticalValues` for exact shared labels, acronyms, method names, and technical terms.
+- Use string `allowIdenticalKeys` entries for exact or wildcard key matches, and `RegExp` entries for broader key families.
+- Use string `allowIdenticalValues` entries for exact shared labels, and `RegExp` entries for structured values such as `HTTP/2`.
+- Add `placeholderPatterns` for framework-specific placeholders such as `%s`, `%(name)s`, or `$1`. Mixed content such as `Total: {count}` is still reported.
+- Set `ignoreCodeLike: false` if paths, colors, acronyms, or identifiers should be shown as findings.
 - Set `ignoreSameLanguageFamily: false` if you want to check regional variants such as `en-GB`, `en-AU`, or `pt-BR`.
 - Set `failOn: 'none'` while tuning a new project, then raise it to `high` or `medium` once the allowlist is stable.
 - Pass `--include-ignored` when reviewing why a value was ignored.
+- Use `source` to choose Vue files for `check-hardcoded`.
+- Tune `hardcoded.vueAttributes` if your project uses additional static attributes for user-visible text.
+- Use `hardcoded.ignoreValues` and `hardcoded.ignorePatterns` for intentional literals such as `OK`, version labels, or product codes.
+
+## Limitations
+
+`check-hardcoded` currently scans Vue templates only. JavaScript, TypeScript, and JSX string detection are not included yet.
 
 ## Notes
 
@@ -225,4 +330,4 @@ npm run check
 
 ## License
 
-MIT
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18n-smell-detector",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Find locale values copied from the base locale.",
   "type": "module",
   "bin": {
@@ -21,7 +21,9 @@
     "LICENSE"
   ],
   "scripts": {
-    "check": "node ./bin/i18n-smell-detector.js check-identical --config ./examples/vue-vite/i18n-smell.config.mjs",
+    "check": "npm run check:identical && npm run check:hardcoded",
+    "check:identical": "node ./bin/i18n-smell-detector.js check-identical --config ./examples/vue-vite/i18n-smell.config.mjs --fail-on none",
+    "check:hardcoded": "node ./bin/i18n-smell-detector.js check-hardcoded --config ./examples/vue-vite/i18n-smell.config.mjs --fail-on none",
     "test": "node --test"
   },
   "keywords": [
@@ -34,5 +36,10 @@
   "license": "MIT",
   "engines": {
     "node": ">=18.17"
+  },
+  "dependencies": {
+    "@vue/compiler-dom": "^3.5.39",
+    "@vue/compiler-sfc": "^3.5.39",
+    "fast-glob": "^3.3.3"
   }
 }

package/src/check-hardcoded.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import fg from 'fast-glob';
+import { scanVueSfc } from './source/scan-vue-sfc.js';
+
+function compareIssues(a, b) {
+  const rank = { high: 3, medium: 2, low: 1, ignored: 0 };
+  return rank[b.severity] - rank[a.severity]
+    || a.file.localeCompare(b.file)
+    || a.line - b.line
+    || a.column - b.column;
+}
+
+export async function checkHardcodedStrings(config, baseDir) {
+  const files = await fg(config.source, {
+    cwd: baseDir,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ['**/node_modules/**'],
+  });
+
+  if (files.length === 0) {
+    throw new Error(`No source files matched: ${config.source.join(', ')}`);
+  }
+
+  const issues = [];
+  for (const file of files) {
+    const fileIssues = await scanVueSfc(file, config);
+    for (const issue of fileIssues) {
+      issues.push({
+        ...issue,
+        file: path.relative(baseDir, issue.file),
+      });
+    }
+  }
+
+  return issues.sort(compareIssues);
+}

package/src/cli.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { checkHardcodedStrings } from './check-hardcoded.js';
 import { checkIdenticalTranslations } from './check-identical.js';
 import { loadConfig, resolveConfigPath } from './config.js';
 import { loadFlattenedLocales } from './locale/load-locales.js';
@@ -6,10 +7,11 @@ import { renderReport } from './reporters/index.js';
 import { failRank, severityRank } from './severity.js';
 
 const HELP = `
-i18n-smell-detector v0.1.1
+i18n-smell-detector
 
 Usage:
   i18n-smell-detector check-identical [options]
+  i18n-smell-detector check-hardcoded [options]
   i18n-smell-detector check [options]
 
 Options:
@@ -21,6 +23,7 @@ Options:
 
 Example:
   i18n-smell-detector check-identical -c i18n-smell.config.mjs --format markdown
+  i18n-smell-detector check-hardcoded -c i18n-smell.config.mjs --format json
 `;
 
 function parseArgs(argv) {
@@ -64,7 +67,7 @@ export async function runCli(argv) {
     return;
   }
 
-  if (!['check-identical', 'check'].includes(options.command)) {
+  if (!['check-identical', 'check-hardcoded', 'check'].includes(options.command)) {
     throw new Error(`Unknown command: ${options.command}\n${HELP}`);
   }
 
@@ -76,12 +79,18 @@ export async function runCli(argv) {
     includeIgnored: options.includeIgnored || config.includeIgnored || false,
   };
 
-  const locales = await loadFlattenedLocales(effectiveConfig, path.dirname(configPath));
-  const issues = checkIdenticalTranslations(locales, effectiveConfig);
+  const configDir = path.dirname(configPath);
+  const isHardcoded = options.command === 'check-hardcoded';
+  const issues = isHardcoded
+    ? await checkHardcodedStrings(effectiveConfig, configDir)
+    : checkIdenticalTranslations(await loadFlattenedLocales(effectiveConfig, configDir), effectiveConfig);
 
   console.log(renderReport(issues, {
     format: options.format,
     includeIgnored: effectiveConfig.includeIgnored || false,
+    title: isHardcoded ? 'hardcoded strings' : 'identical translations',
+    heading: isHardcoded ? 'Hardcoded strings' : 'Identical translations',
+    emptyMessage: isHardcoded ? 'No hardcoded strings found.' : 'No copied base-locale values found.',
   }));
 
   const visible = effectiveConfig.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');

package/src/config.js

@@ -12,6 +12,19 @@ const CONFIG_FILES = [
   'i18n-smell.config.json',
 ];
 
+const DEFAULT_PLACEHOLDER_PATTERNS = [
+  String.raw`\{\{[^}]+\}\}`,
+  String.raw`\{[^}]+\}`,
+];
+
+const DEFAULT_HARDCODED_ATTRIBUTES = [
+  'placeholder',
+  'title',
+  'alt',
+  'aria-label',
+  'aria-description',
+];
+
 async function exists(filePath) {
   try {
     await access(filePath);
@@ -69,6 +82,28 @@ function validateConfig(config) {
       throw new Error(`Config locales.${locale} must be a file path string`);
     }
   }
+
+  validateRuleList(candidate.allowIdenticalKeys, 'allowIdenticalKeys');
+  validateRuleList(candidate.allowIdenticalValues, 'allowIdenticalValues');
+
+  if ('placeholderPatterns' in candidate && !Array.isArray(candidate.placeholderPatterns)) {
+    throw new Error('Config placeholderPatterns must be an array of strings or RegExp objects');
+  }
+
+  if ('source' in candidate && !isStringArray(candidate.source)) {
+    throw new Error('Config source must be an array of glob strings');
+  }
+
+  if ('hardcoded' in candidate && (!candidate.hardcoded || typeof candidate.hardcoded !== 'object' || Array.isArray(candidate.hardcoded))) {
+    throw new Error('Config hardcoded must be an object');
+  }
+
+  const hardcoded = /** @type {Record<string, unknown>} */ (candidate.hardcoded || {});
+  if ('vueAttributes' in hardcoded && !isStringArray(hardcoded.vueAttributes)) {
+    throw new Error('Config hardcoded.vueAttributes must be an array of strings');
+  }
+  validateRuleList(hardcoded.ignoreValues, 'hardcoded.ignoreValues');
+  validateRuleList(hardcoded.ignorePatterns, 'hardcoded.ignorePatterns');
 }
 
 /** @param {import('./types.js').DetectorConfig} config */
@@ -84,5 +119,68 @@ function withDefaults(config) {
     includeIgnored: false,
     failOn: 'high',
     ...config,
+    source: config.source || ['src/**/*.vue'],
+    hardcoded: normalizeHardcodedConfig(config.hardcoded || {}),
+    placeholderPatterns: normalizePlaceholderPatterns(config.placeholderPatterns || DEFAULT_PLACEHOLDER_PATTERNS),
+    ignoreCodeLike: config.ignoreCodeLike ?? true,
   };
 }
+
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === 'string' && item.length > 0);
+}
+
+function validateRuleList(rules, name) {
+  if (rules === undefined) return;
+  if (!Array.isArray(rules)) throw new Error(`Config ${name} must be an array`);
+
+  for (const rule of rules) {
+    if (typeof rule !== 'string' && !(rule instanceof RegExp)) {
+      throw new Error(`Config ${name} entries must be strings or RegExp objects`);
+    }
+  }
+}
+
+function normalizePlaceholderPatterns(patterns) {
+  return patterns.map((pattern) => {
+    if (pattern instanceof RegExp) return withGlobalFlag(pattern);
+
+    if (typeof pattern !== 'string') {
+      throw new Error('Config placeholderPatterns entries must be strings or RegExp objects');
+    }
+
+    try {
+      return new RegExp(pattern, 'g');
+    } catch (error) {
+      throw new Error(`Invalid placeholder pattern "${pattern}": ${error.message}`);
+    }
+  });
+}
+
+function normalizeHardcodedConfig(config) {
+  return {
+    vueAttributes: config.vueAttributes || DEFAULT_HARDCODED_ATTRIBUTES,
+    ignoreValues: config.ignoreValues || [],
+    ignorePatterns: normalizeRegexRules(config.ignorePatterns || [], 'hardcoded.ignorePatterns'),
+  };
+}
+
+function normalizeRegexRules(rules, name) {
+  return rules.map((rule) => {
+    if (rule instanceof RegExp) return rule;
+    if (typeof rule !== 'string') {
+      throw new Error(`Config ${name} entries must be strings or RegExp objects`);
+    }
+
+    try {
+      return new RegExp(rule);
+    } catch (error) {
+      throw new Error(`Invalid ${name} pattern "${rule}": ${error.message}`);
+    }
+  });
+}
+
+function withGlobalFlag(pattern) {
+  const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+  return new RegExp(pattern.source, flags);
+}

package/src/reporters/console.js

@@ -1,3 +1,5 @@
+import { summarizeIssues } from './summary.js';
+
 function color(code, text) {
   if (process.env.NO_COLOR) return text;
   return `\u001b[${code}m${text}\u001b[0m`;
@@ -17,20 +19,20 @@ function preview(value) {
 
 export function renderConsoleReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
-  const counts = countBySeverity(issues);
+  const counts = summarizeIssues(issues);
   const lines = [
-    color('1', 'i18n-smell-detector: identical translations'),
+    color('1', `i18n-smell-detector: ${options.title || 'identical translations'}`),
     `high=${counts.high} medium=${counts.medium} low=${counts.low} ignored=${counts.ignored}`,
   ];
 
   if (visible.length === 0) {
-    lines.push(color('32', 'No copied base-locale values found.'));
+    lines.push(color('32', options.emptyMessage || 'No copied base-locale values found.'));
     return lines.join('\n');
   }
 
   lines.push('');
   for (const issue of visible) {
-    lines.push(`${label(issue.severity)} ${issue.targetLocale}.${issue.key}`);
+    lines.push(`${label(issue.severity)} ${formatLocation(issue)}`);
     lines.push(`  value: "${preview(issue.value)}"`);
     lines.push(`  reason: ${issue.reason}`);
   }
@@ -38,12 +40,7 @@ export function renderConsoleReport(issues, options) {
   return lines.join('\n');
 }
 
-function countBySeverity(issues) {
-  return issues.reduce(
-    (acc, issue) => {
-      acc[issue.severity] += 1;
-      return acc;
-    },
-    { high: 0, medium: 0, low: 0, ignored: 0 }
-  );
+function formatLocation(issue) {
+  if (issue.file) return `${issue.file}:${issue.line}:${issue.column}`;
+  return `${issue.targetLocale}.${issue.key}`;
 }

package/src/reporters/json.js

@@ -1,4 +1,6 @@
+import { summarizeIssues } from './summary.js';
+
 export function renderJsonReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
-  return `${JSON.stringify({ issues: visible }, null, 2)}\n`;
+  return `${JSON.stringify({ summary: summarizeIssues(issues), issues: visible }, null, 2)}\n`;
 }

package/src/reporters/markdown.js

@@ -1,23 +1,48 @@
+import { summarizeIssues } from './summary.js';
+
 function escapeCell(value) {
   return String(value).replace(/\|/g, '\\|').replace(/\n/g, '<br>');
 }
 
 export function renderMarkdownReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
-  const lines = ['# Identical translations', ''];
+  const summary = summarizeIssues(issues);
+  const lines = [
+    `# ${options.heading || 'Identical translations'}`,
+    '',
+    `high=${summary.high} medium=${summary.medium} low=${summary.low} ignored=${summary.ignored}`,
+    '',
+  ];
 
   if (visible.length === 0) {
-    lines.push('No copied base-locale values found.');
+    lines.push(options.emptyMessage || 'No copied base-locale values found.');
     return `${lines.join('\n')}\n`;
   }
 
-  lines.push('| Level | Locale | Key | Value | Reason |');
-  lines.push('|---|---|---|---|---|');
+  if (visible.some((issue) => issue.file)) {
+    lines.push('| Level | Location | Value | Reason |');
+    lines.push('|---|---|---|---|');
+  } else {
+    lines.push('| Level | Locale | Key | Value | Reason |');
+    lines.push('|---|---|---|---|---|');
+  }
+
   for (const issue of visible) {
-    lines.push(
-      `| ${escapeCell(issue.severity)} | ${escapeCell(issue.targetLocale)} | ${escapeCell(issue.key)} | ${escapeCell(issue.value)} | ${escapeCell(issue.reason)} |`
-    );
+    if (issue.file) {
+      lines.push(
+        `| ${escapeCell(issue.severity)} | ${escapeCell(formatLocation(issue))} | ${escapeCell(issue.value)} | ${escapeCell(issue.reason)} |`
+      );
+    } else {
+      lines.push(
+        `| ${escapeCell(issue.severity)} | ${escapeCell(issue.targetLocale)} | ${escapeCell(issue.key)} | ${escapeCell(issue.value)} | ${escapeCell(issue.reason)} |`
+      );
+    }
   }
 
   return `${lines.join('\n')}\n`;
 }
+
+function formatLocation(issue) {
+  if (issue.file) return `${issue.file}:${issue.line}:${issue.column}`;
+  return `${issue.targetLocale}.${issue.key}`;
+}

package/src/reporters/summary.js

@@ -0,0 +1,9 @@
+export function summarizeIssues(issues) {
+  return issues.reduce(
+    (summary, issue) => {
+      summary[issue.severity] += 1;
+      return summary;
+    },
+    { high: 0, medium: 0, low: 0, ignored: 0 }
+  );
+}

package/src/rules/classify-hardcoded.js

@@ -0,0 +1,54 @@
+import { matchesAnyRule } from './match-rule.js';
+
+function isBlank(value) {
+  return value.trim().length === 0;
+}
+
+function isMustacheOnly(value) {
+  return /^\{\{[\s\S]*\}\}$/.test(value.trim());
+}
+
+function isNonUserFacing(value) {
+  const text = value.trim();
+  return /^[0-9.,:;+\-*/%()\s]+$/.test(text)
+    || /^[\p{P}\p{S}]+$/u.test(text)
+    || /^#[0-9a-f]{3,8}$/i.test(text)
+    || /^(https?:\/\/|mailto:|tel:)/i.test(text)
+    || /^\/[a-z0-9_./:-]*$/i.test(text)
+    || /^[a-z0-9_.-]+\.(css|js|png|jpe?g|gif|svg|webp|json)$/i.test(text)
+    || /^[A-Z]{2,6}$/.test(text);
+}
+
+function latinWords(value) {
+  return value.match(/[A-Za-z][A-Za-z']*/g) || [];
+}
+
+function isShortCommonLabel(value) {
+  const text = value.trim();
+  return text.length <= 3 || /^(ok|id|no|yes|on|off)$/i.test(text);
+}
+
+export function classifyHardcoded(value, config = {}) {
+  const hardcoded = config.hardcoded || {};
+
+  if (matchesAnyRule(value, hardcoded.ignoreValues || [])) {
+    return { severity: 'ignored', reason: 'ignored value' };
+  }
+
+  if (matchesAnyRule(value, hardcoded.ignorePatterns || [])) {
+    return { severity: 'ignored', reason: 'ignored pattern' };
+  }
+
+  if (isBlank(value)) return { severity: 'ignored', reason: 'blank value' };
+  if (isMustacheOnly(value)) return { severity: 'ignored', reason: 'mustache expression' };
+  if (isNonUserFacing(value)) return { severity: 'ignored', reason: 'non-user-facing value' };
+  if (isShortCommonLabel(value)) return { severity: 'low', reason: 'short common label' };
+
+  const words = latinWords(value);
+  if (words.length >= 2 || /[.!?。！？]/.test(value)) {
+    return { severity: 'high', reason: 'sentence-like content' };
+  }
+
+  if (words.length === 1) return { severity: 'medium', reason: 'single word' };
+  return { severity: 'low', reason: 'possible user-facing text' };
+}

package/src/rules/classify-identical.js

@@ -1,4 +1,4 @@
-import { matchesAnyPattern } from './match-pattern.js';
+import { matchesAnyRule } from './match-rule.js';
 
 function isBlank(value) {
   return value.trim().length === 0;
@@ -18,12 +18,17 @@ function isCodeLike(value) {
     || (/^[a-z0-9_.:-]+$/.test(text) && !/\s/.test(text) && !/[A-Z]/.test(text));
 }
 
-function isPlaceholderOnly(value) {
-  const text = value
-    .replace(/\{\{\s*[^}]+\s*\}\}/g, '')
-    .replace(/\{\s*[^}]+\s*\}/g, '')
-    .replace(/[\s\p{P}\p{S}]/gu, '');
-  return text.length === 0;
+function isPlaceholderOnly(value, patterns) {
+  let text = value.trim();
+
+  const orderedPatterns = [...(patterns || [])].sort((a, b) => b.source.length - a.source.length);
+
+  for (const pattern of orderedPatterns) {
+    pattern.lastIndex = 0;
+    text = text.replace(pattern, '');
+  }
+
+  return text.trim() === '';
 }
 
 function getLatinWords(value) {
@@ -49,22 +54,22 @@ function isShortCommonLabel(value) {
  * @returns {{ severity: import('../types.js').Severity, reason: string }}
  */
 export function classifyIdentical({ key, value, baseLocale, targetLocale, config }) {
-  if ((config.ignoreSameLanguageFamily ?? true) && languageFamily(baseLocale) === languageFamily(targetLocale)) {
-    return { severity: 'ignored', reason: 'same language family' };
-  }
-
-  if (matchesAnyPattern(key, config.allowIdenticalKeys || [])) {
+  if (matchesAnyRule(key, config.allowIdenticalKeys || [], { wildcard: true })) {
     return { severity: 'ignored', reason: 'allowed key' };
   }
 
-  if ((config.allowIdenticalValues || []).includes(value)) {
+  if (matchesAnyRule(value, config.allowIdenticalValues || [])) {
     return { severity: 'ignored', reason: 'allowed value' };
   }
 
+  if ((config.ignoreSameLanguageFamily ?? true) && languageFamily(baseLocale) === languageFamily(targetLocale)) {
+    return { severity: 'ignored', reason: 'same language family' };
+  }
+
   if (isBlank(value)) return { severity: 'ignored', reason: 'blank value' };
+  if (isPlaceholderOnly(value, config.placeholderPatterns || [])) return { severity: 'ignored', reason: 'placeholder only' };
   if (isExternalReference(value)) return { severity: 'ignored', reason: 'external reference' };
-  if (isPlaceholderOnly(value)) return { severity: 'ignored', reason: 'placeholder only' };
-  if (isCodeLike(value)) return { severity: 'ignored', reason: 'code-like value' };
+  if ((config.ignoreCodeLike ?? true) && isCodeLike(value)) return { severity: 'ignored', reason: 'code-like value' };
   if (isShortCommonLabel(value)) return { severity: 'low', reason: 'short common label' };
 
   const words = getLatinWords(value);

package/src/rules/match-pattern.js

@@ -1,8 +1,5 @@
-function patternToRegExp(pattern) {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-  return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
-}
+import { matchesAnyRule } from './match-rule.js';
 
 export function matchesAnyPattern(value, patterns = []) {
-  return patterns.some((pattern) => patternToRegExp(pattern).test(value));
+  return matchesAnyRule(value, patterns, { wildcard: true });
 }

package/src/rules/match-rule.js

@@ -0,0 +1,21 @@
+function wildcardToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
+}
+
+function testRegExp(value, pattern) {
+  pattern.lastIndex = 0;
+  return pattern.test(value);
+}
+
+export function matchesRule(value, rule, options = {}) {
+  if (rule instanceof RegExp) return testRegExp(value, rule);
+  if (typeof rule !== 'string') return false;
+
+  if (options.wildcard) return wildcardToRegExp(rule).test(value);
+  return value === rule;
+}
+
+export function matchesAnyRule(value, rules = [], options = {}) {
+  return rules.some((rule) => matchesRule(value, rule, options));
+}

package/src/source/scan-vue-sfc.js

@@ -0,0 +1,26 @@
+import { readFile } from 'node:fs/promises';
+import { parse } from '@vue/compiler-sfc';
+import { scanVueTemplate } from './scan-vue-template.js';
+
+function lineOffsetBefore(source, offset) {
+  return source.slice(0, offset).split(/\r?\n/).length - 1;
+}
+
+export async function scanVueSfc(file, config) {
+  const source = await readFile(file, 'utf8');
+  const result = parse(source, { filename: file });
+
+  if (result.errors.length > 0) {
+    const [error] = result.errors;
+    throw new Error(`Malformed Vue file ${file}: ${error.message || String(error)}`);
+  }
+
+  const template = result.descriptor.template;
+  if (!template) return [];
+
+  return scanVueTemplate(template.content, {
+    file,
+    lineOffset: lineOffsetBefore(source, template.loc.start.offset),
+    config,
+  });
+}

package/src/source/scan-vue-template.js

@@ -0,0 +1,105 @@
+import { NodeTypes, parse } from '@vue/compiler-dom';
+import { classifyHardcoded } from '../rules/classify-hardcoded.js';
+
+function offsetToLocation(source, offset) {
+  const before = source.slice(0, offset);
+  const lines = before.split(/\r?\n/);
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length + 1,
+  };
+}
+
+function normalizeText(value) {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+function isI18nExpression(value) {
+  return /\b(?:t|te|\$t|i18n\.t)\s*\(/.test(value);
+}
+
+function makeIssue({ file, lineOffset, template, loc, value, kind, reason, severity }) {
+  const start = offsetToLocation(template, loc.start.offset);
+  return {
+    file,
+    line: lineOffset + start.line,
+    column: start.column,
+    value,
+    severity,
+    reason,
+    kind,
+  };
+}
+
+function scanValue({ file, lineOffset, template, loc, value, kind, baseReason, config }) {
+  const text = normalizeText(value);
+  if (!text) return null;
+
+  const classification = classifyHardcoded(text, config);
+  return makeIssue({
+    file,
+    lineOffset,
+    template,
+    loc,
+    value: text,
+    severity: classification.severity,
+    reason: classification.severity === 'ignored' ? classification.reason : baseReason,
+    kind,
+  });
+}
+
+function walk(node, visitor) {
+  visitor(node);
+  for (const child of node.children || []) walk(child, visitor);
+}
+
+export function scanVueTemplate(template, { file, lineOffset = 0, config }) {
+  let ast;
+  try {
+    ast = parse(template, { comments: false });
+  } catch (error) {
+    throw new Error(`Malformed Vue template in ${file}: ${error.message}`);
+  }
+
+  const attributes = new Set(config.hardcoded.vueAttributes);
+  const issues = [];
+
+  walk(ast, (node) => {
+    if (node.type === NodeTypes.TEXT) {
+      const issue = scanValue({
+        file,
+        lineOffset,
+        template,
+        loc: node.loc,
+        value: node.content,
+        kind: 'vue-text',
+        baseReason: 'static template text',
+        config,
+      });
+      if (issue) issues.push(issue);
+      return;
+    }
+
+    if (node.type !== NodeTypes.ELEMENT) return;
+
+    for (const prop of node.props || []) {
+      if (prop.type !== NodeTypes.ATTRIBUTE) continue;
+      if (!attributes.has(prop.name) || !prop.value) continue;
+      if (isI18nExpression(prop.value.content)) continue;
+
+      const issue = scanValue({
+        file,
+        lineOffset,
+        template,
+        loc: prop.value.loc,
+        value: prop.value.content,
+        kind: `vue-attribute:${prop.name}`,
+        baseReason: `static ${prop.name} attribute`,
+        config,
+      });
+      if (issue) issues.push(issue);
+    }
+  });
+
+  return issues;
+}

package/src/types.js

@@ -5,8 +5,12 @@
  * @typedef {Object} DetectorConfig
  * @property {string} baseLocale
  * @property {Record<string, string>} locales
- * @property {string[]=} allowIdenticalKeys
- * @property {string[]=} allowIdenticalValues
+ * @property {(string | RegExp)[]=} allowIdenticalKeys
+ * @property {(string | RegExp)[]=} allowIdenticalValues
+ * @property {(string | RegExp)[]=} placeholderPatterns
+ * @property {string[]=} source
+ * @property {{vueAttributes: string[], ignoreValues: (string | RegExp)[], ignorePatterns: RegExp[]}=} hardcoded
+ * @property {boolean=} ignoreCodeLike
  * @property {boolean=} ignoreSameLanguageFamily
  * @property {boolean=} trimWhitespace
  * @property {boolean=} ignoreCase
@@ -20,6 +24,15 @@
  * @property {string} value
  * @property {Severity} severity
  * @property {string} reason
+ *
+ * @typedef {Object} HardcodedIssue
+ * @property {string} file
+ * @property {number} line
+ * @property {number} column
+ * @property {string} value
+ * @property {Severity} severity
+ * @property {string} reason
+ * @property {string} kind
  */
 
 export {};