i18n-smell-detector 0.2.0 → 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',
@@ -90,6 +97,22 @@ export default {
   ],
 
   ignoreCodeLike: true,
+  hardcoded: {
+    vueAttributes: [
+      'placeholder',
+      'title',
+      'alt',
+      'aria-label',
+      'aria-description'
+    ],
+    ignoreValues: [
+      'OK',
+      'ID'
+    ],
+    ignorePatterns: [
+      '^v\\d+$'
+    ]
+  },
   ignoreSameLanguageFamily: true,
   trimWhitespace: true,
   ignoreCase: false,
@@ -103,11 +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 \| 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`. |
@@ -173,6 +200,47 @@ Summary counts include all findings, including ignored findings that may be omit
 
 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 |
@@ -194,6 +262,8 @@ Ignored issues are omitted by default. Pass `--include-ignored` to include them
 | 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.
@@ -236,6 +306,13 @@ Useful tuning patterns:
 - 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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18n-smell-detector",
-  "version": "0.2.0",
+  "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 --fail-on none",
+    "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

@@ -17,6 +17,14 @@ const DEFAULT_PLACEHOLDER_PATTERNS = [
   String.raw`\{[^}]+\}`,
 ];
 
+const DEFAULT_HARDCODED_ATTRIBUTES = [
+  'placeholder',
+  'title',
+  'alt',
+  'aria-label',
+  'aria-description',
+];
+
 async function exists(filePath) {
   try {
     await access(filePath);
@@ -81,6 +89,21 @@ function validateConfig(config) {
   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 */
@@ -96,11 +119,17 @@ 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`);
@@ -128,6 +157,29 @@ function normalizePlaceholderPatterns(patterns) {
   });
 }
 
+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

@@ -21,21 +21,26 @@ export function renderConsoleReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
   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}`);
   }
 
   return lines.join('\n');
 }
+
+function formatLocation(issue) {
+  if (issue.file) return `${issue.file}:${issue.line}:${issue.column}`;
+  return `${issue.targetLocale}.${issue.key}`;
+}

package/src/reporters/markdown.js

@@ -8,24 +8,41 @@ export function renderMarkdownReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
   const summary = summarizeIssues(issues);
   const lines = [
-    '# Identical translations',
+    `# ${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/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/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

@@ -8,6 +8,8 @@
  * @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
@@ -22,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 {};