1374 lines
45 KiB
TypeScript
1374 lines
45 KiB
TypeScript
import { NextResponse } from 'next/server';
|
|
import { promises as fs } from 'fs';
|
|
import path from 'path';
|
|
|
|
import { en } from '@/app/i18n/translations/en';
|
|
import { de } from '@/app/i18n/translations/de';
|
|
import { flattenObject } from '@/app/i18n/dynamicTranslations';
|
|
import { requireAdminSession } from '../../_utils/backendAuth';
|
|
|
|
const EXCLUDED_DIRS = new Set([
|
|
'.git',
|
|
'.next',
|
|
'node_modules',
|
|
'dist',
|
|
'build',
|
|
'coverage',
|
|
'out',
|
|
'.turbo',
|
|
]);
|
|
|
|
const SCANNED_EXTENSIONS = new Set([
|
|
'.ts',
|
|
'.tsx',
|
|
'.js',
|
|
'.jsx',
|
|
'.mjs',
|
|
'.cjs',
|
|
'.json',
|
|
'.html',
|
|
'.md',
|
|
]);
|
|
|
|
const MAX_FILE_SIZE_BYTES = 1024 * 1024; // 1 MB per file
|
|
|
|
type MissingKeyMap = Map<string, Set<string>>;
|
|
|
|
interface ScanResult {
|
|
scannedFiles: number;
|
|
scannedDirectories: number;
|
|
translationCallCount: number;
|
|
uniqueKeyCount: number;
|
|
missingKeys: Array<{ key: string; files: string[] }>;
|
|
untranslatedLiterals: Array<{ text: string; files: string[] }>;
|
|
autoFixEligibleFiles: string[];
|
|
autoFixForceConvertibleFiles: string[];
|
|
}
|
|
|
|
interface AutoFixChange {
|
|
file: string;
|
|
replacements: number;
|
|
addedImport: boolean;
|
|
addedHook: boolean;
|
|
}
|
|
|
|
interface AutoFixResult {
|
|
changedFiles: AutoFixChange[];
|
|
skippedFiles: Array<{ file: string; reason: string }>;
|
|
createdKeys: string[];
|
|
debugEntries: AutoFixDebugEntry[];
|
|
}
|
|
|
|
interface AutoFixDebugEntry {
|
|
file: string;
|
|
status: 'changed' | 'skipped' | 'no-op';
|
|
beforeLiteralCount: number;
|
|
textReplacements: number;
|
|
attrReplacements: number;
|
|
afterLiteralCount: number;
|
|
reason?: string;
|
|
}
|
|
|
|
interface AutoFixOptions {
|
|
targetFiles?: Set<string>;
|
|
forceConvertToClient?: boolean;
|
|
}
|
|
|
|
interface AddMissingKeysResult {
|
|
createdKeys: string[];
|
|
}
|
|
|
|
const TRANSLATABLE_ATTRIBUTES = ['placeholder', 'title', 'alt', 'aria-label'] as const;
|
|
const USE_CLIENT_PREFIX_REGEX = /^\uFEFF?\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*['\"]use client['\"]\s*;?\s*/;
|
|
const LEADING_PREAMBLE_REGEX = /^\uFEFF?\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*/;
|
|
const JSX_TAG_REGEX = /<(?:[^'"<>]|"[^"]*"|'[^']*'|\{[^{}]*\})+>/g;
|
|
|
|
async function walk(dir: string, outFiles: string[], counters: { dirs: number }) {
|
|
counters.dirs += 1;
|
|
const entries = await fs.readdir(dir, { withFileTypes: true });
|
|
|
|
for (const entry of entries) {
|
|
const fullPath = path.join(dir, entry.name);
|
|
|
|
if (entry.isDirectory()) {
|
|
if (!EXCLUDED_DIRS.has(entry.name)) {
|
|
await walk(fullPath, outFiles, counters);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (!entry.isFile()) continue;
|
|
|
|
const ext = path.extname(entry.name).toLowerCase();
|
|
if (!SCANNED_EXTENSIONS.has(ext)) continue;
|
|
|
|
const stat = await fs.stat(fullPath);
|
|
if (stat.size > MAX_FILE_SIZE_BYTES) continue;
|
|
|
|
outFiles.push(fullPath);
|
|
}
|
|
}
|
|
|
|
function extractTranslationKeys(content: string): string[] {
|
|
const keys: string[] = [];
|
|
const regexes = [
|
|
/\bt\(\s*['"`]([^'"`]+)['"`]\s*[,)\]]/g,
|
|
/\bgetEnglishValue\(\s*['"`]([^'"`]+)['"`]\s*\)/g,
|
|
];
|
|
|
|
for (const regex of regexes) {
|
|
let match: RegExpExecArray | null = null;
|
|
while ((match = regex.exec(content)) !== null) {
|
|
if (match[1]) keys.push(match[1]);
|
|
}
|
|
}
|
|
|
|
return keys;
|
|
}
|
|
|
|
function isLikelyStaticTranslationKey(key: string): boolean {
|
|
const trimmed = key.trim();
|
|
if (!trimmed) return false;
|
|
// Dynamic template fragments cannot be validated as missing static keys.
|
|
if (trimmed.includes('${')) return false;
|
|
// Accept typical dotted key paths only.
|
|
if (!/^[A-Za-z0-9_.-]+$/.test(trimmed)) return false;
|
|
// Ignore placeholder examples like "..." that appear in help text.
|
|
if (!/[A-Za-z0-9]/.test(trimmed)) return false;
|
|
return true;
|
|
}
|
|
|
|
function isUiCodeFile(filePath: string): boolean {
|
|
const ext = path.extname(filePath).toLowerCase();
|
|
return ext === '.tsx' || ext === '.jsx';
|
|
}
|
|
|
|
function extractPotentialUiLiterals(content: string): string[] {
|
|
const literals: string[] = [];
|
|
|
|
// Text nodes in JSX, e.g. >Welcome back<
|
|
const jsxTextRegex = />\s*([^<>{}\n][^<>{}\n]{1,})\s*</g;
|
|
let match: RegExpExecArray | null = null;
|
|
while ((match = jsxTextRegex.exec(content)) !== null) {
|
|
const text = match[1]?.replace(/\s+/g, ' ').trim();
|
|
if (!text) continue;
|
|
literals.push(text);
|
|
}
|
|
|
|
// Simple quoted JSX attribute literals, e.g. placeholder="Search..."
|
|
const attrRegex = /\b(?:placeholder|title|alt|aria-label)\s*=\s*(['"])([^"'{}<>\n][^"'<>\n]*)\1/g;
|
|
while ((match = attrRegex.exec(content)) !== null) {
|
|
const text = match[2]?.replace(/\s+/g, ' ').trim();
|
|
if (!text) continue;
|
|
literals.push(text);
|
|
}
|
|
|
|
// Simple JSX child expressions, e.g. >{isSaving ? 'Saving' : 'Save'}<
|
|
const jsxExpressionRegex = />\s*\{([^{}\n][^{}]*?)\}\s*</g;
|
|
while ((match = jsxExpressionRegex.exec(content)) !== null) {
|
|
const expression = String(match[1] ?? '');
|
|
for (const text of extractSimpleExpressionLiterals(expression)) {
|
|
literals.push(text);
|
|
}
|
|
}
|
|
|
|
const confirmRegex = /\bwindow\.confirm\(\s*(['"])([^"'\\]*(?:\\.[^"'\\]*)*)\1\s*\)/g;
|
|
while ((match = confirmRegex.exec(content)) !== null) {
|
|
const text = match[2]?.replace(/\s+/g, ' ').trim();
|
|
if (!text) continue;
|
|
literals.push(text);
|
|
}
|
|
|
|
const messageRegex = /\bmessage\s*:\s*(['"])([^"'\\]*(?:\\.[^"'\\]*)*)\1/g;
|
|
while ((match = messageRegex.exec(content)) !== null) {
|
|
const text = match[2]?.replace(/\s+/g, ' ').trim();
|
|
if (!text) continue;
|
|
literals.push(text);
|
|
}
|
|
|
|
return literals;
|
|
}
|
|
|
|
function extractSimpleExpressionLiterals(expression: string): string[] {
|
|
const literals: string[] = [];
|
|
|
|
const directMatch = expression.match(/^\s*(['"])([^"'\\]*(?:\\.[^"'\\]*)*)\1\s*$/);
|
|
if (directMatch?.[2]) {
|
|
literals.push(directMatch[2].replace(/\s+/g, ' ').trim());
|
|
}
|
|
|
|
for (const match of expression.matchAll(/(?:\?\?|\|\||\?|:)\s*(['"])([^"'\\]*(?:\\.[^"'\\]*)*)\1/g)) {
|
|
const text = match[2]?.replace(/\s+/g, ' ').trim();
|
|
if (!text) continue;
|
|
literals.push(text);
|
|
}
|
|
|
|
return literals;
|
|
}
|
|
|
|
function shouldIgnoreLiteral(text: string): boolean {
|
|
const trimmed = text.trim();
|
|
if (!trimmed) return true;
|
|
if (trimmed.length < 3) return true;
|
|
|
|
// Ignore non-user-facing technical fragments
|
|
if (/^(https?:|\/|\.|#|\{|\}|\[|\]|\(|\)|;|,|\+|-|\*|=|&&|\|\|)/.test(trimmed)) return true;
|
|
if (!/[A-Za-zÀ-ÿ]/.test(trimmed)) return true;
|
|
if (/^&[a-z]+;$/i.test(trimmed)) return true;
|
|
if (/[{}()[\];]|=>|===|!==|&&|\|\||::/.test(trimmed)) return true;
|
|
if (/React\.|TouchEvent|MouseEvent|ChangeEvent|KeyboardEvent|SyntheticEvent/.test(trimmed)) return true;
|
|
if (/^[0-9]+\s*[)&|]/.test(trimmed)) return true;
|
|
if (/^[|><=+\-/*]+/.test(trimmed)) return true;
|
|
if (/^[a-z0-9._/-]+$/i.test(trimmed) && !/\s/.test(trimmed)) return true;
|
|
if (/^(use client|true|false|null|undefined)$/i.test(trimmed)) return true;
|
|
if (/(className|onClick|href|src|aria-|data-)/.test(trimmed)) return true;
|
|
if (/^[A-Za-z0-9_.]+\s*:\s*[A-Za-z0-9_.]+$/.test(trimmed)) return true;
|
|
if (/\|/.test(trimmed) && /\b(void|Promise|string|number|boolean|any|unknown|never|null|undefined|Record|React)\b/.test(trimmed)) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
function escapeForTsString(value: string): string {
|
|
return value
|
|
.replace(/\\/g, '\\\\')
|
|
.replace(/'/g, "\\'")
|
|
.replace(/\r?\n/g, ' ')
|
|
.trim();
|
|
}
|
|
|
|
function escapeForQuotedString(value: string, quote: '\'' | '"'): string {
|
|
const normalized = value
|
|
.replace(/\\/g, '\\\\')
|
|
.replace(/\r?\n/g, ' ')
|
|
.trim();
|
|
|
|
return quote === '\''
|
|
? normalized.replace(/'/g, "\\'")
|
|
: normalized.replace(/"/g, '\\"');
|
|
}
|
|
|
|
function hashText(input: string): string {
|
|
let hash = 5381;
|
|
for (let i = 0; i < input.length; i += 1) {
|
|
hash = ((hash << 5) + hash) ^ input.charCodeAt(i);
|
|
}
|
|
return Math.abs(hash >>> 0).toString(16).padStart(8, '0');
|
|
}
|
|
|
|
function toAutofixKey(text: string): string {
|
|
return `autofix.k${hashText(text)}`;
|
|
}
|
|
|
|
function hasUseClientDirective(content: string): boolean {
|
|
return USE_CLIENT_PREFIX_REGEX.test(content);
|
|
}
|
|
|
|
function isAutoFixCandidatePath(relPath: string): boolean {
|
|
if (!relPath.startsWith('src/app/')) return false;
|
|
if (relPath.startsWith('src/app/api/')) return false;
|
|
if (relPath.startsWith('src/app/i18n/')) return false;
|
|
// Portal component renders outside any React context provider — hooks like
|
|
// useTranslation must not be injected here by the autofix.
|
|
if (relPath.endsWith('components/toast/toastComponent.tsx')) return false;
|
|
return true;
|
|
}
|
|
|
|
function hasUseTranslationImport(content: string): boolean {
|
|
return /from\s+['\"][^'\"]*\/i18n\/useTranslation['\"];?/.test(content);
|
|
}
|
|
|
|
function hasTHook(content: string): boolean {
|
|
return /const\s*\{\s*t\s*\}\s*=\s*useTranslation\s*\(/.test(content);
|
|
}
|
|
|
|
function hasExistingTUsage(content: string): boolean {
|
|
return /\bt\(\s*['"`][^'"`]+['"`]\s*[,\)\]]/.test(content);
|
|
}
|
|
|
|
function validateAutoFixOutput(content: string): string | null {
|
|
const duplicateImports = content.match(/import\s+\{\s*useTranslation\s*\}\s+from\s+['\"][^'\"]*\/i18n\/useTranslation['\"];?/g) ?? [];
|
|
if (duplicateImports.length > 1) {
|
|
return 'Unsafe autofix output: duplicate useTranslation import detected.';
|
|
}
|
|
|
|
const functionPatterns = [
|
|
/(?:^|\n)\s*export\s+default\s+async\s+function\s+\w*\s*\([\s\S]*?\)\s*\{/gm,
|
|
/(?:^|\n)\s*export\s+default\s+function\s+\w*\s*\([\s\S]*?\)\s*\{/gm,
|
|
/(?:^|\n)\s*export\s+async\s+function\s+\w+\s*\([\s\S]*?\)\s*\{/gm,
|
|
/(?:^|\n)\s*export\s+function\s+\w+\s*\([\s\S]*?\)\s*\{/gm,
|
|
/(?:^|\n)\s*async\s+function\s+\w+\s*\([\s\S]*?\)\s*\{/gm,
|
|
/(?:^|\n)\s*function\s+\w+\s*\([\s\S]*?\)\s*\{/gm,
|
|
/(?:^|\n)\s*const\s+\w+\s*:\s*[^=\n]+\s*=\s*async\s*\([\s\S]*?\)\s*=>\s*\{/gm,
|
|
/(?:^|\n)\s*const\s+\w+\s*:\s*[^=\n]+\s*=\s*\([\s\S]*?\)\s*=>\s*\{/gm,
|
|
/(?:^|\n)\s*const\s+\w+\s*=\s*async\s*\([\s\S]*?\)\s*=>\s*\{/gm,
|
|
/(?:^|\n)\s*const\s+\w+\s*=\s*\([\s\S]*?\)\s*=>\s*\{/gm,
|
|
];
|
|
|
|
const findFunctionBodyEnd = (source: string, bodyStart: number): number | null => {
|
|
let depth = 1;
|
|
let inSingleQuote = false;
|
|
let inDoubleQuote = false;
|
|
let inTemplate = false;
|
|
let inLineComment = false;
|
|
let inBlockComment = false;
|
|
|
|
for (let index = bodyStart; index < source.length; index += 1) {
|
|
const char = source[index];
|
|
const prev = index > 0 ? source[index - 1] : '';
|
|
const next = index + 1 < source.length ? source[index + 1] : '';
|
|
|
|
if (inLineComment) {
|
|
if (char === '\n') inLineComment = false;
|
|
continue;
|
|
}
|
|
|
|
if (inBlockComment) {
|
|
if (prev === '*' && char === '/') inBlockComment = false;
|
|
continue;
|
|
}
|
|
|
|
if (inSingleQuote) {
|
|
if (char === '\'' && prev !== '\\') inSingleQuote = false;
|
|
continue;
|
|
}
|
|
|
|
if (inDoubleQuote) {
|
|
if (char === '"' && prev !== '\\') inDoubleQuote = false;
|
|
continue;
|
|
}
|
|
|
|
if (inTemplate) {
|
|
if (char === '`' && prev !== '\\') inTemplate = false;
|
|
continue;
|
|
}
|
|
|
|
if (char === '/' && next === '/') {
|
|
inLineComment = true;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === '/' && next === '*') {
|
|
inBlockComment = true;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === '\'') {
|
|
inSingleQuote = true;
|
|
continue;
|
|
}
|
|
|
|
if (char === '"') {
|
|
inDoubleQuote = true;
|
|
continue;
|
|
}
|
|
|
|
if (char === '`') {
|
|
inTemplate = true;
|
|
continue;
|
|
}
|
|
|
|
if (char === '{') {
|
|
depth += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === '}') {
|
|
depth -= 1;
|
|
if (depth === 0) return index;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
const processedBodyStarts = new Set<number>();
|
|
|
|
for (const pattern of functionPatterns) {
|
|
for (const match of content.matchAll(pattern)) {
|
|
if (typeof match.index !== 'number') continue;
|
|
const bodyStart = match.index + match[0].length;
|
|
if (processedBodyStarts.has(bodyStart)) continue;
|
|
processedBodyStarts.add(bodyStart);
|
|
const bodyEnd = findFunctionBodyEnd(content, bodyStart);
|
|
if (bodyEnd === null) continue;
|
|
const bodyContent = content.slice(bodyStart, bodyEnd);
|
|
const hookMatches = bodyContent.match(/const\s*\{\s*t\s*\}\s*=\s*useTranslation\s*\(\)\s*;?/g) ?? [];
|
|
if (hookMatches.length > 1) {
|
|
return 'Unsafe autofix output: duplicate useTranslation hooks detected in a function scope.';
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function hasServerOnlySignals(content: string): string | null {
|
|
if (/from\s+['\"]next\/headers['\"]/.test(content)) return 'uses next/headers';
|
|
if (/from\s+['\"]next\/server['\"]/.test(content)) return 'uses next/server';
|
|
if (/\bexport\s+const\s+metadata\b/.test(content)) return 'exports metadata';
|
|
if (/\bexport\s+async\s+function\s+generateMetadata\b/.test(content)) return 'uses generateMetadata';
|
|
if (/\bexport\s+default\s+async\s+function\b/.test(content)) return 'default component is async (server-style)';
|
|
return null;
|
|
}
|
|
|
|
function insertUseClientDirective(content: string): { content: string; added: boolean } {
|
|
if (hasUseClientDirective(content)) return { content, added: false };
|
|
|
|
const match = content.match(LEADING_PREAMBLE_REGEX);
|
|
const at = match ? match[0].length : 0;
|
|
const before = content.slice(0, at);
|
|
const after = content.slice(at);
|
|
const spacer = before.endsWith('\n') || before.length === 0 ? '' : '\n';
|
|
const next = `${before}${spacer}'use client';\n\n${after}`;
|
|
return { content: next, added: true };
|
|
}
|
|
|
|
function ensureUseTranslation(
|
|
content: string,
|
|
filePathAbs: string,
|
|
options: { forceConvertToClient?: boolean } = {}
|
|
): { content: string; addedImport: boolean; addedHook: boolean; reason?: string } {
|
|
let next = content;
|
|
|
|
if (!hasUseClientDirective(content)) {
|
|
if (hasTHook(content) || hasExistingTUsage(content)) {
|
|
return { content, addedImport: false, addedHook: false };
|
|
}
|
|
|
|
if (!options.forceConvertToClient) {
|
|
return { content, addedImport: false, addedHook: false, reason: "File is not a client component ('use client')." };
|
|
}
|
|
|
|
const signal = hasServerOnlySignals(content);
|
|
if (signal) {
|
|
return {
|
|
content,
|
|
addedImport: false,
|
|
addedHook: false,
|
|
reason: `Force convert skipped: file appears server-only (${signal}).`,
|
|
};
|
|
}
|
|
|
|
next = insertUseClientDirective(content).content;
|
|
}
|
|
|
|
let addedImport = false;
|
|
let addedHook = false;
|
|
|
|
if (!hasUseTranslationImport(next)) {
|
|
const fileDir = path.dirname(filePathAbs);
|
|
const importTarget = path.join(process.cwd(), 'src', 'app', 'i18n', 'useTranslation');
|
|
let rel = path.relative(fileDir, importTarget).split(path.sep).join('/');
|
|
if (!rel.startsWith('.')) rel = `./${rel}`;
|
|
|
|
const importLine = `import { useTranslation } from '${rel}';\n`;
|
|
const useClientMatch = next.match(USE_CLIENT_PREFIX_REGEX);
|
|
if (!useClientMatch || typeof useClientMatch.index !== 'number') {
|
|
return { content, addedImport: false, addedHook: false, reason: 'Could not place import statement.' };
|
|
}
|
|
const at = useClientMatch.index + useClientMatch[0].length;
|
|
next = `${next.slice(0, at)}\n\n${importLine}${next.slice(at)}`;
|
|
addedImport = true;
|
|
}
|
|
|
|
if (!hasTHook(next)) {
|
|
const fnPatterns = [
|
|
/export\s+default\s+function\s+\w+\s*\([\s\S]*?\)\s*\{/m,
|
|
/function\s+\w+\s*\([\s\S]*?\)\s*\{/m,
|
|
/const\s+\w+\s*=\s*\([\s\S]*?\)\s*=>\s*\{/m,
|
|
/const\s+\w+\s*:\s*[^=\n]+\s*=\s*\([\s\S]*?\)\s*=>\s*\{/m,
|
|
];
|
|
|
|
let inserted = false;
|
|
for (const pattern of fnPatterns) {
|
|
const match = next.match(pattern);
|
|
if (!match || typeof match.index !== 'number') continue;
|
|
const at = match.index + match[0].length;
|
|
next = `${next.slice(0, at)}\n const { t } = useTranslation();${next.slice(at)}`;
|
|
inserted = true;
|
|
addedHook = true;
|
|
break;
|
|
}
|
|
|
|
if (!inserted) {
|
|
return { content, addedImport: false, addedHook: false, reason: 'Could not locate a component function to inject useTranslation().' };
|
|
}
|
|
}
|
|
|
|
return { content: next, addedImport, addedHook };
|
|
}
|
|
|
|
function ensureUseTranslationHooksInComponents(content: string): { content: string; addedHooks: number } {
|
|
if (!/\bt\(\s*['"`][^'"`]+['"`]/.test(content)) {
|
|
return { content, addedHooks: 0 };
|
|
}
|
|
|
|
const componentPatterns = [
|
|
/export\s+default\s+function\s+\w+\s*\([\s\S]*?\)\s*\{/gm,
|
|
/export\s+function\s+[A-Z]\w*\s*\([\s\S]*?\)\s*\{/gm,
|
|
/function\s+[A-Z]\w*\s*\([\s\S]*?\)\s*\{/gm,
|
|
/const\s+[A-Z]\w*\s*=\s*\([\s\S]*?\)\s*=>\s*\{/gm,
|
|
/const\s+[A-Z]\w*\s*:\s*[^=\n]+\s*=\s*\([\s\S]*?\)\s*=>\s*\{/gm,
|
|
];
|
|
|
|
const hookPrefixRegex = /^\s*(?:\/\/[^\n]*\n\s*|\/\*[\s\S]*?\*\/\s*)*const\s*\{\s*t\s*\}\s*=\s*useTranslation\s*\(\)\s*;?/;
|
|
const insertPositions = new Set<number>();
|
|
|
|
const findFunctionBodyEnd = (source: string, bodyStart: number): number | null => {
|
|
let depth = 1;
|
|
let inSingleQuote = false;
|
|
let inDoubleQuote = false;
|
|
let inTemplate = false;
|
|
let inLineComment = false;
|
|
let inBlockComment = false;
|
|
|
|
for (let index = bodyStart; index < source.length; index += 1) {
|
|
const char = source[index];
|
|
const prev = index > 0 ? source[index - 1] : '';
|
|
const next = index + 1 < source.length ? source[index + 1] : '';
|
|
|
|
if (inLineComment) {
|
|
if (char === '\n') inLineComment = false;
|
|
continue;
|
|
}
|
|
|
|
if (inBlockComment) {
|
|
if (prev === '*' && char === '/') inBlockComment = false;
|
|
continue;
|
|
}
|
|
|
|
if (inSingleQuote) {
|
|
if (char === '\'' && prev !== '\\') inSingleQuote = false;
|
|
continue;
|
|
}
|
|
|
|
if (inDoubleQuote) {
|
|
if (char === '"' && prev !== '\\') inDoubleQuote = false;
|
|
continue;
|
|
}
|
|
|
|
if (inTemplate) {
|
|
if (char === '`' && prev !== '\\') inTemplate = false;
|
|
continue;
|
|
}
|
|
|
|
if (char === '/' && next === '/') {
|
|
inLineComment = true;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === '/' && next === '*') {
|
|
inBlockComment = true;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === '\'') {
|
|
inSingleQuote = true;
|
|
continue;
|
|
}
|
|
|
|
if (char === '"') {
|
|
inDoubleQuote = true;
|
|
continue;
|
|
}
|
|
|
|
if (char === '`') {
|
|
inTemplate = true;
|
|
continue;
|
|
}
|
|
|
|
if (char === '{') {
|
|
depth += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === '}') {
|
|
depth -= 1;
|
|
if (depth === 0) {
|
|
return index;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
for (const pattern of componentPatterns) {
|
|
for (const match of content.matchAll(pattern)) {
|
|
if (typeof match.index !== 'number') continue;
|
|
const bodyStart = match.index + match[0].length;
|
|
const bodyEnd = findFunctionBodyEnd(content, bodyStart);
|
|
if (bodyEnd === null) continue;
|
|
const bodyContent = content.slice(bodyStart, bodyEnd);
|
|
if (!/\bt\(\s*['"`][^'"`]+['"`]/.test(bodyContent)) continue;
|
|
const bodyPrefix = content.slice(bodyStart, bodyStart + 200);
|
|
if (hookPrefixRegex.test(bodyPrefix)) continue;
|
|
insertPositions.add(bodyStart);
|
|
}
|
|
}
|
|
|
|
if (insertPositions.size === 0) {
|
|
return { content, addedHooks: 0 };
|
|
}
|
|
|
|
let next = content;
|
|
const positions = Array.from(insertPositions).sort((a, b) => b - a);
|
|
for (const position of positions) {
|
|
next = `${next.slice(0, position)}\n const { t } = useTranslation();${next.slice(position)}`;
|
|
}
|
|
|
|
return { content: next, addedHooks: positions.length };
|
|
}
|
|
|
|
function isIndexInsideStringOrComment(source: string, index: number): boolean {
|
|
let inSingleQuote = false;
|
|
let inDoubleQuote = false;
|
|
let inTemplateLiteral = false;
|
|
let inLineComment = false;
|
|
let inBlockComment = false;
|
|
|
|
for (let i = 0; i < source.length; i += 1) {
|
|
if (i >= index) {
|
|
return inSingleQuote || inDoubleQuote || inTemplateLiteral || inLineComment || inBlockComment;
|
|
}
|
|
|
|
const char = source[i];
|
|
const prev = i > 0 ? source[i - 1] : '';
|
|
const next = i + 1 < source.length ? source[i + 1] : '';
|
|
|
|
if (inLineComment) {
|
|
if (char === '\n') {
|
|
inLineComment = false;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (inBlockComment) {
|
|
if (prev === '*' && char === '/') {
|
|
inBlockComment = false;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (inSingleQuote) {
|
|
if (char === '\'' && prev !== '\\') {
|
|
inSingleQuote = false;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (inDoubleQuote) {
|
|
if (char === '"' && prev !== '\\') {
|
|
inDoubleQuote = false;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (inTemplateLiteral) {
|
|
if (char === '`' && prev !== '\\') {
|
|
inTemplateLiteral = false;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (char === '/' && next === '/') {
|
|
inLineComment = true;
|
|
i += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === '/' && next === '*') {
|
|
inBlockComment = true;
|
|
i += 1;
|
|
continue;
|
|
}
|
|
|
|
if (char === '\'') {
|
|
inSingleQuote = true;
|
|
continue;
|
|
}
|
|
|
|
if (char === '"') {
|
|
inDoubleQuote = true;
|
|
continue;
|
|
}
|
|
|
|
if (char === '`') {
|
|
inTemplateLiteral = true;
|
|
}
|
|
}
|
|
|
|
return inSingleQuote || inDoubleQuote || inTemplateLiteral || inLineComment || inBlockComment;
|
|
}
|
|
|
|
function replaceJsxAttributeLiterals(content: string): { content: string; replacements: number; keyValueMap: Map<string, string> } {
|
|
const keyValueMap = new Map<string, string>();
|
|
let replacements = 0;
|
|
|
|
const attrsPattern = TRANSLATABLE_ATTRIBUTES.map((a) => a.replace('-', '\\-')).join('|');
|
|
const attrRegex = new RegExp(`\\b(${attrsPattern})\\s*=\\s*(["'])([^"'{}\\n][^"'\\n]*)\\2`, 'g');
|
|
|
|
// Only rewrite inside JSX tag bodies, never in TS/JS function params or object literals.
|
|
const next = content.replace(JSX_TAG_REGEX, (tag, tagOffset: number) => {
|
|
if (isIndexInsideStringOrComment(content, tagOffset)) {
|
|
return tag;
|
|
}
|
|
|
|
return tag.replace(attrRegex, (full, attrName: string, quote: string, captured: string) => {
|
|
const text = String(captured ?? '').replace(/\s+/g, ' ').trim();
|
|
if (shouldIgnoreLiteral(text)) return full;
|
|
|
|
const key = toAutofixKey(text);
|
|
keyValueMap.set(key, text);
|
|
replacements += 1;
|
|
return `${attrName}={t('${key}')}`;
|
|
});
|
|
});
|
|
|
|
return { content: next, replacements, keyValueMap };
|
|
}
|
|
|
|
function replaceJsxTextNodes(content: string): { content: string; replacements: number; keyValueMap: Map<string, string> } {
|
|
const keyValueMap = new Map<string, string>();
|
|
let replacements = 0;
|
|
|
|
const jsxTextRegex = />\s*([^<>{}\n][^<>{}\n]{1,})\s*</g;
|
|
const next = content.replace(jsxTextRegex, (full, captured: string, offset: number) => {
|
|
if (isIndexInsideStringOrComment(content, offset)) {
|
|
return full;
|
|
}
|
|
|
|
const text = String(captured ?? '').replace(/\s+/g, ' ').trim();
|
|
if (shouldIgnoreLiteral(text)) return full;
|
|
|
|
const key = toAutofixKey(text);
|
|
keyValueMap.set(key, text);
|
|
replacements += 1;
|
|
return `>{t('${key}')}<`;
|
|
});
|
|
|
|
return { content: next, replacements, keyValueMap };
|
|
}
|
|
|
|
function replaceSimpleExpressionLiterals(expression: string, keyValueMap: Map<string, string>): { expression: string; replacements: number } {
|
|
let replacements = 0;
|
|
|
|
const directMatch = expression.match(/^\s*(['"])([^"'\\]*(?:\\.[^"'\\]*)*)\1\s*$/);
|
|
if (directMatch?.[2]) {
|
|
const text = directMatch[2].replace(/\s+/g, ' ').trim();
|
|
if (!shouldIgnoreLiteral(text)) {
|
|
const key = toAutofixKey(text);
|
|
keyValueMap.set(key, text);
|
|
return { expression: `t('${key}')`, replacements: 1 };
|
|
}
|
|
}
|
|
|
|
const nextExpression = expression.replace(/(\?\?|\|\||\?|:)\s*(['"])([^"'\\]*(?:\\.[^"'\\]*)*)\2/g, (full, operator: string, quote: string, captured: string) => {
|
|
const text = String(captured ?? '').replace(/\s+/g, ' ').trim();
|
|
if (shouldIgnoreLiteral(text)) return full;
|
|
|
|
const key = toAutofixKey(text);
|
|
keyValueMap.set(key, text);
|
|
replacements += 1;
|
|
return `${operator} t('${key}')`;
|
|
});
|
|
|
|
return { expression: nextExpression, replacements };
|
|
}
|
|
|
|
function replaceJsxExpressionLiterals(content: string): { content: string; replacements: number; keyValueMap: Map<string, string> } {
|
|
const keyValueMap = new Map<string, string>();
|
|
let replacements = 0;
|
|
|
|
const next = content.replace(/>\s*\{([^{}\n][^{}]*?)\}\s*</g, (full, captured: string, offset: number) => {
|
|
if (isIndexInsideStringOrComment(content, offset)) {
|
|
return full;
|
|
}
|
|
|
|
const result = replaceSimpleExpressionLiterals(String(captured ?? ''), keyValueMap);
|
|
replacements += result.replacements;
|
|
return result.replacements > 0 ? `>{${result.expression}}<` : full;
|
|
});
|
|
|
|
return { content: next, replacements, keyValueMap };
|
|
}
|
|
|
|
function replaceCommonCallLiterals(content: string): { content: string; replacements: number; keyValueMap: Map<string, string> } {
|
|
const keyValueMap = new Map<string, string>();
|
|
let replacements = 0;
|
|
|
|
let next = content.replace(/\bwindow\.confirm\(\s*(['"])([^"'\\]*(?:\\.[^"'\\]*)*)\1\s*\)/g, (full, quote: string, captured: string, offset: number) => {
|
|
if (isIndexInsideStringOrComment(content, offset)) {
|
|
return full;
|
|
}
|
|
|
|
const text = String(captured ?? '').replace(/\s+/g, ' ').trim();
|
|
if (shouldIgnoreLiteral(text)) return full;
|
|
|
|
const key = toAutofixKey(text);
|
|
keyValueMap.set(key, text);
|
|
replacements += 1;
|
|
return `window.confirm(t('${key}'))`;
|
|
});
|
|
|
|
next = next.replace(/\bmessage\s*:\s*(['"])([^"'\\]*(?:\\.[^"'\\]*)*)\1/g, (full, quote: string, captured: string, offset: number) => {
|
|
if (isIndexInsideStringOrComment(next, offset)) {
|
|
return full;
|
|
}
|
|
|
|
const text = String(captured ?? '').replace(/\s+/g, ' ').trim();
|
|
if (shouldIgnoreLiteral(text)) return full;
|
|
|
|
const key = toAutofixKey(text);
|
|
keyValueMap.set(key, text);
|
|
replacements += 1;
|
|
return `message: t('${key}')`;
|
|
});
|
|
|
|
next = next.replace(/\bmessage\s*:\s*([^,\n]+?)(\?\?|\|\|)\s*(['"])([^"'\\]*(?:\\.[^"'\\]*)*)\3/g, (full, before: string, operator: string, quote: string, captured: string, offset: number) => {
|
|
if (isIndexInsideStringOrComment(next, offset)) {
|
|
return full;
|
|
}
|
|
|
|
const text = String(captured ?? '').replace(/\s+/g, ' ').trim();
|
|
if (shouldIgnoreLiteral(text)) return full;
|
|
|
|
const key = toAutofixKey(text);
|
|
keyValueMap.set(key, text);
|
|
replacements += 1;
|
|
return `message: ${before}${operator} t('${key}')`;
|
|
});
|
|
|
|
return { content: next, replacements, keyValueMap };
|
|
}
|
|
|
|
function upsertAutofixNamespace(content: string, entries: Map<string, string>): string {
|
|
if (entries.size === 0) return content;
|
|
|
|
const autofixBlockRegex = /\n(\s*)((?:"autofix"|autofix)\s*:\s*\{)([\s\S]*?)\n\1\},/m;
|
|
const match = content.match(autofixBlockRegex);
|
|
|
|
if (match) {
|
|
const indent = match[1] ?? ' ';
|
|
const blockHeader = match[2] ?? 'autofix: {';
|
|
const blockBody = match[3] ?? '';
|
|
const trimmedBlockBody = blockBody.replace(/\s*$/, '');
|
|
const trailingWhitespace = blockBody.slice(trimmedBlockBody.length);
|
|
const existing = new Set<string>();
|
|
for (const m of blockBody.matchAll(/\n\s{4}(?:"([A-Za-z0-9_]+)"|([A-Za-z0-9_]+))\s*:\s*['"]/g)) {
|
|
const keyName = m[1] || m[2];
|
|
if (keyName) {
|
|
existing.add(`autofix.${keyName}`);
|
|
}
|
|
}
|
|
|
|
const useQuotedKeys = /"[A-Za-z0-9_]+"\s*:/.test(blockBody) || /"autofix"\s*:/.test(blockHeader);
|
|
const valueQuote: '\'' | '"' = /:\s*"/.test(blockBody) ? '"' : '\'';
|
|
|
|
const entryLines = Array.from(entries.entries())
|
|
.sort((a, b) => a[0].localeCompare(b[0]))
|
|
.map(([key, value]) => {
|
|
const shortKey = key.replace(/^autofix\./, '');
|
|
const renderedKey = useQuotedKeys ? `"${shortKey}"` : shortKey;
|
|
return `${indent} ${renderedKey}: ${valueQuote}${escapeForQuotedString(value, valueQuote)}${valueQuote},`;
|
|
});
|
|
|
|
const missing = entryLines.filter((line) => {
|
|
const m = line.match(/^\s+(?:"([A-Za-z0-9_]+)"|([A-Za-z0-9_]+))\s*:/);
|
|
if (!m) return false;
|
|
const keyName = m[1] || m[2];
|
|
return keyName ? !existing.has(`autofix.${keyName}`) : false;
|
|
});
|
|
|
|
if (missing.length === 0) return content;
|
|
|
|
const normalizedBlockBody =
|
|
trimmedBlockBody.length === 0 || trimmedBlockBody.endsWith(',')
|
|
? blockBody
|
|
: `${trimmedBlockBody},${trailingWhitespace}`;
|
|
|
|
const replacement = `\n${indent}${blockHeader}${normalizedBlockBody}\n${missing.join('\n')}\n${indent}},`;
|
|
return content.replace(autofixBlockRegex, replacement);
|
|
}
|
|
|
|
const toastsKeyMatch = content.match(/\n(\s*)((?:"toasts"|toasts)\s*:)/m);
|
|
if (toastsKeyMatch) {
|
|
const indent = toastsKeyMatch[1] ?? ' ';
|
|
const useQuotedKeys = /"toasts"\s*:/.test(toastsKeyMatch[2] ?? '');
|
|
const valueQuote: '\'' | '"' = /"[A-Za-z0-9_]+"\s*:\s*"/.test(content) ? '"' : '\'';
|
|
const entryLines = Array.from(entries.entries())
|
|
.sort((a, b) => a[0].localeCompare(b[0]))
|
|
.map(([key, value]) => {
|
|
const shortKey = key.replace(/^autofix\./, '');
|
|
const renderedKey = useQuotedKeys ? `"${shortKey}"` : shortKey;
|
|
return `${indent} ${renderedKey}: ${valueQuote}${escapeForQuotedString(value, valueQuote)}${valueQuote},`;
|
|
});
|
|
|
|
const autofixHeader = useQuotedKeys ? '"autofix": {' : 'autofix: {';
|
|
const autofixBlock = `\n${indent}${autofixHeader}\n${entryLines.join('\n')}\n${indent}},\n`;
|
|
return content.replace(/\n\s*(?:"toasts"|toasts)\s*:/m, `${autofixBlock}\n${indent}${toastsKeyMatch[2]}`);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
|
|
function upsertAutofixType(content: string): string {
|
|
// Already has a Record<string,string> entry (any indentation)
|
|
if (/\n\s*autofix:\s*Record<string,\s*string>;/.test(content)) {
|
|
return content;
|
|
}
|
|
// Already has a proper block entry
|
|
if (/\n\s*autofix:\s*\{/.test(content)) {
|
|
return content;
|
|
}
|
|
|
|
const insertBefore = /\n\s{2}\/\/\s*─+\s*Notifications\s*\/\s*Toasts[\s\S]*?\n\s{2}toasts:/m;
|
|
if (!insertBefore.test(content)) return content;
|
|
|
|
const block = `\n autofix: Record<string, string>;\n`;
|
|
return content.replace(insertBefore, `${block}\n // ─── Notifications / Toasts ────────────────────────────\n toasts:`);
|
|
}
|
|
|
|
async function runAutoFix(options: AutoFixOptions = {}): Promise<AutoFixResult> {
|
|
const workspaceRoot = process.cwd();
|
|
const files: string[] = [];
|
|
const counters = { dirs: 0 };
|
|
|
|
await walk(workspaceRoot, files, counters);
|
|
|
|
const uiFiles = files.filter((f) => {
|
|
const ext = path.extname(f).toLowerCase();
|
|
if (ext !== '.tsx' && ext !== '.jsx') return false;
|
|
const rel = toRelativeWorkspacePath(f);
|
|
if (!isAutoFixCandidatePath(rel)) return false;
|
|
if (options.targetFiles && options.targetFiles.size > 0 && !options.targetFiles.has(rel)) return false;
|
|
return true;
|
|
});
|
|
|
|
const changedFiles: AutoFixChange[] = [];
|
|
const skippedFiles: Array<{ file: string; reason: string }> = [];
|
|
const createdEntries = new Map<string, string>();
|
|
const debugEntries: AutoFixDebugEntry[] = [];
|
|
|
|
if (options.targetFiles && options.targetFiles.size > 0) {
|
|
const discoveredSet = new Set(files.map((f) => toRelativeWorkspacePath(f)));
|
|
const eligibleSet = new Set(uiFiles.map((f) => toRelativeWorkspacePath(f)));
|
|
|
|
for (const target of options.targetFiles) {
|
|
if (!discoveredSet.has(target)) {
|
|
skippedFiles.push({ file: target, reason: 'Target file was not found in workspace scan.' });
|
|
debugEntries.push({
|
|
file: target,
|
|
status: 'skipped',
|
|
beforeLiteralCount: 0,
|
|
textReplacements: 0,
|
|
attrReplacements: 0,
|
|
afterLiteralCount: 0,
|
|
reason: 'Target file was not found in workspace scan.',
|
|
});
|
|
continue;
|
|
}
|
|
if (!eligibleSet.has(target)) {
|
|
skippedFiles.push({ file: target, reason: 'Target file is not eligible for auto-fix (requires TSX/JSX under src/app).' });
|
|
debugEntries.push({
|
|
file: target,
|
|
status: 'skipped',
|
|
beforeLiteralCount: 0,
|
|
textReplacements: 0,
|
|
attrReplacements: 0,
|
|
afterLiteralCount: 0,
|
|
reason: 'Target file is not eligible for auto-fix (requires TSX/JSX under src/app).',
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const absPath of uiFiles) {
|
|
const relPath = toRelativeWorkspacePath(absPath);
|
|
const raw = await fs.readFile(absPath, 'utf8');
|
|
|
|
const literalCheck = extractPotentialUiLiterals(raw).filter((text) => !shouldIgnoreLiteral(text));
|
|
if (literalCheck.length === 0) {
|
|
debugEntries.push({
|
|
file: relPath,
|
|
status: 'no-op',
|
|
beforeLiteralCount: 0,
|
|
textReplacements: 0,
|
|
attrReplacements: 0,
|
|
afterLiteralCount: 0,
|
|
reason: 'No potential untranslated literals remained in this file.',
|
|
});
|
|
continue;
|
|
}
|
|
|
|
const ensured = ensureUseTranslation(raw, absPath, { forceConvertToClient: options.forceConvertToClient });
|
|
if (ensured.reason) {
|
|
skippedFiles.push({ file: relPath, reason: ensured.reason });
|
|
debugEntries.push({
|
|
file: relPath,
|
|
status: 'skipped',
|
|
beforeLiteralCount: literalCheck.length,
|
|
textReplacements: 0,
|
|
attrReplacements: 0,
|
|
afterLiteralCount: literalCheck.length,
|
|
reason: ensured.reason,
|
|
});
|
|
continue;
|
|
}
|
|
|
|
const textReplaced = replaceJsxTextNodes(ensured.content);
|
|
const exprReplaced = replaceJsxExpressionLiterals(textReplaced.content);
|
|
const attrReplaced = replaceJsxAttributeLiterals(exprReplaced.content);
|
|
const callReplaced = replaceCommonCallLiterals(attrReplaced.content);
|
|
const ensuredHooks = ensureUseTranslationHooksInComponents(callReplaced.content);
|
|
const totalReplacements = textReplaced.replacements + exprReplaced.replacements + attrReplaced.replacements + callReplaced.replacements;
|
|
const afterLiteralCount = extractPotentialUiLiterals(ensuredHooks.content).filter((text) => !shouldIgnoreLiteral(text)).length;
|
|
if (totalReplacements === 0) {
|
|
const reason = 'No supported replacement patterns matched these literals (likely complex JSX/expression cases).';
|
|
skippedFiles.push({ file: relPath, reason });
|
|
debugEntries.push({
|
|
file: relPath,
|
|
status: 'skipped',
|
|
beforeLiteralCount: literalCheck.length,
|
|
textReplacements: 0,
|
|
attrReplacements: 0,
|
|
afterLiteralCount,
|
|
reason,
|
|
});
|
|
continue;
|
|
}
|
|
|
|
const validationIssue = validateAutoFixOutput(ensuredHooks.content);
|
|
if (validationIssue) {
|
|
skippedFiles.push({ file: relPath, reason: validationIssue });
|
|
debugEntries.push({
|
|
file: relPath,
|
|
status: 'skipped',
|
|
beforeLiteralCount: literalCheck.length,
|
|
textReplacements: textReplaced.replacements + exprReplaced.replacements + callReplaced.replacements,
|
|
attrReplacements: attrReplaced.replacements,
|
|
afterLiteralCount,
|
|
reason: validationIssue,
|
|
});
|
|
continue;
|
|
}
|
|
|
|
for (const [k, v] of textReplaced.keyValueMap.entries()) {
|
|
createdEntries.set(k, v);
|
|
}
|
|
for (const [k, v] of exprReplaced.keyValueMap.entries()) {
|
|
createdEntries.set(k, v);
|
|
}
|
|
for (const [k, v] of attrReplaced.keyValueMap.entries()) {
|
|
createdEntries.set(k, v);
|
|
}
|
|
for (const [k, v] of callReplaced.keyValueMap.entries()) {
|
|
createdEntries.set(k, v);
|
|
}
|
|
|
|
if (ensuredHooks.content !== raw) {
|
|
await fs.writeFile(absPath, ensuredHooks.content, 'utf8');
|
|
changedFiles.push({
|
|
file: relPath,
|
|
replacements: totalReplacements,
|
|
addedImport: ensured.addedImport,
|
|
addedHook: ensured.addedHook || ensuredHooks.addedHooks > 0,
|
|
});
|
|
debugEntries.push({
|
|
file: relPath,
|
|
status: 'changed',
|
|
beforeLiteralCount: literalCheck.length,
|
|
textReplacements: textReplaced.replacements + exprReplaced.replacements + callReplaced.replacements,
|
|
attrReplacements: attrReplaced.replacements,
|
|
afterLiteralCount,
|
|
});
|
|
} else {
|
|
debugEntries.push({
|
|
file: relPath,
|
|
status: 'no-op',
|
|
beforeLiteralCount: literalCheck.length,
|
|
textReplacements: textReplaced.replacements + exprReplaced.replacements + callReplaced.replacements,
|
|
attrReplacements: attrReplaced.replacements,
|
|
afterLiteralCount,
|
|
reason: 'Generated output matched input; no file write needed.',
|
|
});
|
|
}
|
|
}
|
|
|
|
if (createdEntries.size > 0) {
|
|
const enPath = path.join(process.cwd(), 'src', 'app', 'i18n', 'translations', 'en.ts');
|
|
const dePath = path.join(process.cwd(), 'src', 'app', 'i18n', 'translations', 'de.ts');
|
|
const typesPath = path.join(process.cwd(), 'src', 'app', 'i18n', 'types.ts');
|
|
|
|
const [enRaw, deRaw, typesRaw] = await Promise.all([
|
|
fs.readFile(enPath, 'utf8'),
|
|
fs.readFile(dePath, 'utf8'),
|
|
fs.readFile(typesPath, 'utf8'),
|
|
]);
|
|
|
|
const nextEn = upsertAutofixNamespace(enRaw, createdEntries);
|
|
const nextDe = upsertAutofixNamespace(deRaw, createdEntries);
|
|
const nextTypes = upsertAutofixType(typesRaw);
|
|
|
|
await Promise.all([
|
|
nextEn !== enRaw ? fs.writeFile(enPath, nextEn, 'utf8') : Promise.resolve(),
|
|
nextDe !== deRaw ? fs.writeFile(dePath, nextDe, 'utf8') : Promise.resolve(),
|
|
nextTypes !== typesRaw ? fs.writeFile(typesPath, nextTypes, 'utf8') : Promise.resolve(),
|
|
]);
|
|
}
|
|
|
|
return {
|
|
changedFiles,
|
|
skippedFiles,
|
|
createdKeys: Array.from(createdEntries.keys()).sort(),
|
|
debugEntries,
|
|
};
|
|
}
|
|
|
|
async function addMissingAutofixKeysToTranslations(missingKeys: string[]): Promise<AddMissingKeysResult> {
|
|
const autofixMissing = missingKeys
|
|
.map((key) => key.trim())
|
|
.filter((key) => /^autofix\.[A-Za-z0-9_]+$/.test(key));
|
|
|
|
if (autofixMissing.length === 0) {
|
|
return { createdKeys: [] };
|
|
}
|
|
|
|
const enFlat = flattenObject(en as unknown as Record<string, unknown>);
|
|
const deFlat = flattenObject(de as unknown as Record<string, unknown>);
|
|
const entriesForEn = new Map<string, string>();
|
|
const entriesForDe = new Map<string, string>();
|
|
|
|
for (const key of autofixMissing) {
|
|
if (Object.prototype.hasOwnProperty.call(enFlat, key)) continue;
|
|
|
|
const deValue = typeof deFlat[key] === 'string' ? String(deFlat[key]) : '';
|
|
const fallbackValue = key;
|
|
|
|
entriesForEn.set(key, deValue || fallbackValue);
|
|
entriesForDe.set(key, deValue || fallbackValue);
|
|
}
|
|
|
|
if (entriesForEn.size === 0) {
|
|
return { createdKeys: [] };
|
|
}
|
|
|
|
const enPath = path.join(process.cwd(), 'src', 'app', 'i18n', 'translations', 'en.ts');
|
|
const dePath = path.join(process.cwd(), 'src', 'app', 'i18n', 'translations', 'de.ts');
|
|
const typesPath = path.join(process.cwd(), 'src', 'app', 'i18n', 'types.ts');
|
|
|
|
const [enRaw, deRaw, typesRaw] = await Promise.all([
|
|
fs.readFile(enPath, 'utf8'),
|
|
fs.readFile(dePath, 'utf8'),
|
|
fs.readFile(typesPath, 'utf8'),
|
|
]);
|
|
|
|
const nextEn = upsertAutofixNamespace(enRaw, entriesForEn);
|
|
const nextDe = upsertAutofixNamespace(deRaw, entriesForDe);
|
|
const nextTypes = upsertAutofixType(typesRaw);
|
|
|
|
await Promise.all([
|
|
nextEn !== enRaw ? fs.writeFile(enPath, nextEn, 'utf8') : Promise.resolve(),
|
|
nextDe !== deRaw ? fs.writeFile(dePath, nextDe, 'utf8') : Promise.resolve(),
|
|
nextTypes !== typesRaw ? fs.writeFile(typesPath, nextTypes, 'utf8') : Promise.resolve(),
|
|
]);
|
|
|
|
return {
|
|
createdKeys: Array.from(entriesForEn.keys()).sort(),
|
|
};
|
|
}
|
|
|
|
function toRelativeWorkspacePath(absPath: string): string {
|
|
const rel = path.relative(process.cwd(), absPath);
|
|
return rel.split(path.sep).join('/');
|
|
}
|
|
|
|
async function runWorkspaceScan(): Promise<ScanResult> {
|
|
const workspaceRoot = process.cwd();
|
|
const files: string[] = [];
|
|
const counters = { dirs: 0 };
|
|
|
|
await walk(workspaceRoot, files, counters);
|
|
|
|
const englishKeys = new Set(Object.keys(flattenObject(en as unknown as Record<string, unknown>)));
|
|
const uniqueUsedKeys = new Set<string>();
|
|
const missingKeyFiles: MissingKeyMap = new Map();
|
|
const untranslatedLiteralFiles: Map<string, Set<string>> = new Map();
|
|
const autoFixEligibleFilesSet = new Set<string>();
|
|
const autoFixForceConvertibleFilesSet = new Set<string>();
|
|
|
|
let translationCallCount = 0;
|
|
|
|
for (const filePath of files) {
|
|
const raw = await fs.readFile(filePath, 'utf8');
|
|
const relativePath = toRelativeWorkspacePath(filePath);
|
|
|
|
const usedKeys = extractTranslationKeys(raw);
|
|
if (usedKeys.length > 0) {
|
|
const staticKeys = usedKeys.filter(isLikelyStaticTranslationKey);
|
|
translationCallCount += staticKeys.length;
|
|
|
|
for (const key of staticKeys) {
|
|
uniqueUsedKeys.add(key);
|
|
|
|
if (!englishKeys.has(key)) {
|
|
if (!missingKeyFiles.has(key)) {
|
|
missingKeyFiles.set(key, new Set<string>());
|
|
}
|
|
missingKeyFiles.get(key)?.add(relativePath);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isUiCodeFile(filePath)) {
|
|
const literals = extractPotentialUiLiterals(raw).filter((text) => !shouldIgnoreLiteral(text));
|
|
for (const text of literals) {
|
|
if (!untranslatedLiteralFiles.has(text)) {
|
|
untranslatedLiteralFiles.set(text, new Set<string>());
|
|
}
|
|
untranslatedLiteralFiles.get(text)?.add(relativePath);
|
|
}
|
|
|
|
if (literals.length > 0 && isAutoFixCandidatePath(relativePath) && (hasUseClientDirective(raw) || hasExistingTUsage(raw))) {
|
|
autoFixEligibleFilesSet.add(relativePath);
|
|
}
|
|
|
|
if (literals.length > 0 && isAutoFixCandidatePath(relativePath)) {
|
|
autoFixForceConvertibleFilesSet.add(relativePath);
|
|
}
|
|
}
|
|
}
|
|
|
|
const missingKeys = Array.from(missingKeyFiles.entries())
|
|
.map(([key, fileSet]) => ({ key, files: Array.from(fileSet).sort() }))
|
|
.sort((a, b) => a.key.localeCompare(b.key));
|
|
|
|
const untranslatedLiterals = Array.from(untranslatedLiteralFiles.entries())
|
|
.map(([text, fileSet]) => ({ text, files: Array.from(fileSet).sort() }))
|
|
.sort((a, b) => b.files.length - a.files.length || a.text.localeCompare(b.text))
|
|
.slice(0, 300);
|
|
|
|
return {
|
|
scannedFiles: files.length,
|
|
scannedDirectories: counters.dirs,
|
|
translationCallCount,
|
|
uniqueKeyCount: uniqueUsedKeys.size,
|
|
missingKeys,
|
|
untranslatedLiterals,
|
|
autoFixEligibleFiles: Array.from(autoFixEligibleFilesSet).sort((a, b) => a.localeCompare(b)),
|
|
autoFixForceConvertibleFiles: Array.from(autoFixForceConvertibleFilesSet).sort((a, b) => a.localeCompare(b)),
|
|
};
|
|
}
|
|
|
|
export async function GET(request: Request) {
|
|
const access = await requireAdminSession(request);
|
|
if (!access.ok) return access.response;
|
|
|
|
try {
|
|
const result = await runWorkspaceScan();
|
|
return NextResponse.json({
|
|
ok: true,
|
|
scannedAt: new Date().toISOString(),
|
|
...result,
|
|
});
|
|
} catch (error) {
|
|
console.error('Workspace i18n scan failed:', error);
|
|
return NextResponse.json(
|
|
{
|
|
ok: false,
|
|
message: 'Workspace scan failed.',
|
|
},
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
}
|
|
|
|
export async function POST(request: Request) {
|
|
const access = await requireAdminSession(request);
|
|
if (!access.ok) return access.response;
|
|
|
|
try {
|
|
let targetFilesSet: Set<string> | undefined;
|
|
let forceConvertToClient = false;
|
|
let mode: 'autofix' | 'add-missing-keys' = 'autofix';
|
|
try {
|
|
const body = await request.json();
|
|
if (body?.mode === 'add-missing-keys') {
|
|
mode = 'add-missing-keys';
|
|
}
|
|
const raw = Array.isArray(body?.targetFiles) ? body.targetFiles : [];
|
|
forceConvertToClient = Boolean(body?.forceConvertToClient);
|
|
const cleaned = raw
|
|
.filter((v: unknown) => typeof v === 'string')
|
|
.map((v: string) => v.trim())
|
|
.filter((v: string) => v.length > 0);
|
|
if (cleaned.length > 0) {
|
|
targetFilesSet = new Set(cleaned);
|
|
}
|
|
} catch {
|
|
// allow empty body (fix all eligible files)
|
|
}
|
|
|
|
if (mode === 'add-missing-keys') {
|
|
const preScan = await runWorkspaceScan();
|
|
const addResult = await addMissingAutofixKeysToTranslations(preScan.missingKeys.map((entry) => entry.key));
|
|
const scanResult = await runWorkspaceScan();
|
|
|
|
return NextResponse.json({
|
|
ok: true,
|
|
mode,
|
|
fixedAt: new Date().toISOString(),
|
|
changedFileCount: 0,
|
|
changedFiles: [],
|
|
skippedFiles: [],
|
|
autoFixDebug: [],
|
|
createdKeyCount: addResult.createdKeys.length,
|
|
createdKeys: addResult.createdKeys,
|
|
...scanResult,
|
|
});
|
|
}
|
|
|
|
const fixResult = await runAutoFix({ targetFiles: targetFilesSet, forceConvertToClient });
|
|
const scanResult = await runWorkspaceScan();
|
|
|
|
console.info('[i18n-autofix] Summary', {
|
|
targetFileCount: targetFilesSet ? targetFilesSet.size : null,
|
|
forceConvertToClient,
|
|
changedFileCount: fixResult.changedFiles.length,
|
|
skippedFileCount: fixResult.skippedFiles.length,
|
|
createdKeyCount: fixResult.createdKeys.length,
|
|
});
|
|
for (const entry of fixResult.debugEntries.slice(0, 200)) {
|
|
console.info('[i18n-autofix:file]', entry);
|
|
}
|
|
|
|
return NextResponse.json({
|
|
ok: true,
|
|
mode: 'autofix',
|
|
fixedAt: new Date().toISOString(),
|
|
forceConvertToClient,
|
|
targetFilesApplied: targetFilesSet ? Array.from(targetFilesSet).sort() : null,
|
|
changedFileCount: fixResult.changedFiles.length,
|
|
changedFiles: fixResult.changedFiles,
|
|
skippedFiles: fixResult.skippedFiles,
|
|
autoFixDebug: fixResult.debugEntries,
|
|
createdKeyCount: fixResult.createdKeys.length,
|
|
createdKeys: fixResult.createdKeys,
|
|
...scanResult,
|
|
});
|
|
} catch (error) {
|
|
console.error('Workspace i18n auto-fix failed:', error);
|
|
return NextResponse.json(
|
|
{
|
|
ok: false,
|
|
message: 'Workspace auto-fix failed.',
|
|
},
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
}
|