deep-slop 1.4.1

package/dist/i18n-lint-CPzx7V8Q.js

@@ -0,0 +1,605 @@
+import { i as toLines, r as readFileContent } from "./file-utils-B_HFXhCs.js";
+import { extname, join, relative } from "node:path";
+import { readdir, stat } from "node:fs/promises";
+
+//#region src/engines/i18n-lint/index.ts
+/** Build a diagnostic with common fields filled */
+function diag(opts) {
+	return {
+		filePath: opts.filePath,
+		engine: "i18n-lint",
+		rule: opts.rule,
+		severity: opts.severity,
+		message: opts.message,
+		help: opts.help,
+		line: opts.line,
+		column: opts.column,
+		category: "i18n",
+		fixable: opts.fixable,
+		suggestion: opts.suggestion,
+		detail: opts.detail
+	};
+}
+/** Determine language from file extension */
+function languageFromPath(filePath) {
+	const ext = extname(filePath);
+	return {
+		".ts": "typescript",
+		".tsx": "typescript",
+		".js": "javascript",
+		".jsx": "javascript",
+		".mjs": "javascript",
+		".cjs": "javascript"
+	}[ext] ?? null;
+}
+/** Check if a file is a JSX/TSX file */
+function isJsxFile(filePath) {
+	const ext = extname(filePath);
+	return ext === ".tsx" || ext === ".jsx";
+}
+/** Technical terms that should not be flagged as hardcoded strings */
+const TECHNICAL_TERMS = new Set([
+	"OK",
+	"ok",
+	"Ok",
+	"ID",
+	"id",
+	"Id",
+	"URL",
+	"url",
+	"Url",
+	"URI",
+	"uri",
+	"Uri",
+	"API",
+	"api",
+	"Api",
+	"HTTP",
+	"http",
+	"Http",
+	"HTTPS",
+	"https",
+	"Https",
+	"CSS",
+	"css",
+	"Css",
+	"HTML",
+	"html",
+	"Html",
+	"JSON",
+	"json",
+	"Json",
+	"XML",
+	"xml",
+	"Xml",
+	"SQL",
+	"sql",
+	"Sql",
+	"SSH",
+	"ssh",
+	"Ssh",
+	"TCP",
+	"tcp",
+	"Tcp",
+	"UDP",
+	"udp",
+	"Udp",
+	"IP",
+	"ip",
+	"Ip",
+	"JWT",
+	"jwt",
+	"Jwt",
+	"UUID",
+	"uuid",
+	"Uuid",
+	"OTP",
+	"otp",
+	"Otp",
+	"MFA",
+	"mfa",
+	"Mfa",
+	"SEO",
+	"seo",
+	"Seo",
+	"CDN",
+	"cdn",
+	"Cdn",
+	"DOM",
+	"dom",
+	"Dom",
+	"SDK",
+	"sdk",
+	"Sdk",
+	"CLI",
+	"cli",
+	"Cli",
+	"GUI",
+	"gui",
+	"Gui",
+	"PDF",
+	"pdf",
+	"Pdf",
+	"FAQ",
+	"faq",
+	"Faq",
+	"DOI",
+	"doi",
+	"Doi",
+	"ISBN",
+	"isbn",
+	"Isbn",
+	"UTC",
+	"utc",
+	"Utc",
+	"GMT",
+	"gmt",
+	"Gmt",
+	"NaN",
+	"nan",
+	"true",
+	"false",
+	"null",
+	"undefined",
+	"yes",
+	"no",
+	"Yes",
+	"No",
+	"on",
+	"off",
+	"On",
+	"Off",
+	"N/A",
+	"n/a"
+]);
+/** Props that carry user-facing strings and should be i18n'd */
+const I18N_PROPS = new Set([
+	"placeholder",
+	"title",
+	"aria-label",
+	"alt",
+	"label"
+]);
+/** Check if a string is emoji-only */
+function isEmojiOnly(str) {
+	const trimmed = str.trim();
+	if (trimmed.length === 0) return false;
+	return /^[\p{Emoji_Presentation}\p{Extended_Pictographic}\u200d\ufe0f\s]+$/u.test(trimmed);
+}
+/** Check if a string is a pure number */
+function isNumberOnly(str) {
+	const trimmed = str.trim();
+	return /^[\d.,\-+%]+$/.test(trimmed);
+}
+/** Check if a string is just whitespace / formatting */
+function isWhitespaceOnly(str) {
+	return str.trim().length === 0;
+}
+/** Check if a string is a single word (no spaces, no hyphens connecting words) */
+function isSingleWord(str) {
+	const trimmed = str.trim();
+	return trimmed.length > 0 && !/\s/.test(trimmed) && !/[-–—]/.test(trimmed);
+}
+/** Check if a string is a technical term */
+function isTechnicalTerm(str) {
+	return TECHNICAL_TERMS.has(str.trim());
+}
+/** Check if a hardcoded string should be skipped (not reported) */
+function shouldSkipJsxString(str) {
+	const trimmed = str.trim();
+	if (trimmed.length === 0) return true;
+	if (isWhitespaceOnly(str)) return true;
+	if (isEmojiOnly(trimmed)) return true;
+	if (isNumberOnly(trimmed)) return true;
+	if (isSingleWord(trimmed) && isTechnicalTerm(trimmed)) return true;
+	if (isSingleWord(trimmed) && /^[a-z_$][a-zA-Z0-9_$]*$/.test(trimmed)) return true;
+	if (/^[a-z-]+$/.test(trimmed) && trimmed.length <= 20) return true;
+	if (/^[^\w\s]+$/u.test(trimmed)) return true;
+	if (isSingleWord(trimmed) && trimmed.length <= 2) return true;
+	return false;
+}
+/**
+* Detect hardcoded string literals in JSX text content (between tags).
+* Pattern: `<div>Hello World</div>` or `<p>Submit Form</p>`
+* Skip: single words, technical terms, emoji-only, numbers, whitespace.
+*/
+function detectHardcodedStringJsx(content, lines, filePath) {
+	const results = [];
+	const jsxTextPattern = />([^<{]+)</g;
+	let match;
+	while ((match = jsxTextPattern.exec(content)) !== null) {
+		const rawText = match[1];
+		match[0];
+		if (shouldSkipJsxString(rawText)) continue;
+		if (isSingleWord(rawText.trim()) && isTechnicalTerm(rawText.trim())) continue;
+		if (isSingleWord(rawText.trim())) {
+			const word = rawText.trim();
+			if (/^[a-z_$][a-zA-Z0-9_$]*$/.test(word)) continue;
+		}
+		const matchStart = match.index;
+		const lineInfo = findLineByOffset(lines, matchStart);
+		if (!lineInfo) continue;
+		const col = lineInfo.text.indexOf(rawText.trim()) + 1 || lineInfo.col;
+		results.push(diag({
+			filePath,
+			rule: "i18n-lint/hardcoded-string-jsx",
+			severity: "info",
+			message: `Hardcoded string in JSX: "${rawText.trim()}" — should use i18n translation`,
+			help: "Replace with a translation key, e.g. <div>{t('key')}</div> or <Trans i18nKey=\"key\" />",
+			line: lineInfo.line,
+			column: Math.max(col, 1),
+			fixable: true,
+			suggestion: {
+				type: "replace",
+				text: `{t('${toKeyHint(rawText.trim())}')}`,
+				confidence: .6,
+				reason: "Replacing hardcoded JSX text with a translation call enables i18n support."
+			},
+			detail: { text: rawText.trim() }
+		}));
+	}
+	return results;
+}
+/** Convert a user-facing string to a suggested translation key */
+function toKeyHint(text) {
+	return text.replace(/[^a-zA-Z0-9\s]/g, "").trim().split(/\s+/).map((w, i) => i === 0 ? w.toLowerCase() : w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("") || "translationKey";
+}
+/** Find line number and column from a character offset in the content */
+function findLineByOffset(lines, offset) {
+	let cumLen = 0;
+	for (const { num, text } of lines) {
+		const lineLen = text.length + 1;
+		if (cumLen + lineLen > offset) return {
+			line: num,
+			col: offset - cumLen + 1,
+			text
+		};
+		cumLen += lineLen;
+	}
+	return null;
+}
+/**
+* Detect hardcoded user-facing strings in component props:
+* placeholder=, title=, aria-label=, alt= (on images), label=
+* Skip: CSS class names, technical props (type=, name=, id=)
+*/
+function detectHardcodedStringProps(content, lines, filePath) {
+	const results = [];
+	for (const prop of I18N_PROPS) {
+		const doubleQuotedRe = new RegExp(`\\b${escapeRegex(prop)}\\s*=\\s*"([^"]+)"`, "g");
+		let match;
+		while ((match = doubleQuotedRe.exec(content)) !== null) {
+			const value = match[1];
+			if (shouldSkipPropValue(value, prop)) continue;
+			const lineInfo = findLineByOffset(lines, match.index);
+			if (!lineInfo) continue;
+			results.push(makePropDiag(filePath, prop, value, lineInfo));
+		}
+		const singleQuotedRe = new RegExp(`\\b${escapeRegex(prop)}\\s*=\\s*'([^']+)'`, "g");
+		while ((match = singleQuotedRe.exec(content)) !== null) {
+			const value = match[1];
+			if (shouldSkipPropValue(value, prop)) continue;
+			const lineInfo = findLineByOffset(lines, match.index);
+			if (!lineInfo) continue;
+			results.push(makePropDiag(filePath, prop, value, lineInfo));
+		}
+		const templateRe = new RegExp(`\\b${escapeRegex(prop)}\\s*=\\s*\\{\\s*\`([^\`]+)\`\\s*\\}`, "g");
+		while ((match = templateRe.exec(content)) !== null) {
+			const value = match[1];
+			if (shouldSkipPropValue(value, prop)) continue;
+			const lineInfo = findLineByOffset(lines, match.index);
+			if (!lineInfo) continue;
+			results.push(makePropDiag(filePath, prop, value, lineInfo));
+		}
+	}
+	return results;
+}
+function makePropDiag(filePath, prop, value, lineInfo) {
+	return diag({
+		filePath,
+		rule: "i18n-lint/hardcoded-string-props",
+		severity: "warning",
+		message: `Hardcoded string in "${prop}" prop: "${value}" — should use i18n translation`,
+		help: `Replace with a translation expression: ${prop}={t('${toKeyHint(value)}')}`,
+		line: lineInfo.line,
+		column: Math.max(lineInfo.text.indexOf(prop) + 1, 1),
+		fixable: true,
+		suggestion: {
+			type: "replace",
+			text: `${prop}={t('${toKeyHint(value)}')}`,
+			confidence: .65,
+			reason: `Prop "${prop}" should use a translation key instead of a hardcoded string for i18n support.`
+		},
+		detail: {
+			prop,
+			value
+		}
+	});
+}
+/** Skip prop values that aren't really user-facing */
+function shouldSkipPropValue(value, prop) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return true;
+	if (isEmojiOnly(trimmed)) return true;
+	if (isNumberOnly(trimmed)) return true;
+	if (trimmed === "") return true;
+	if (prop === "alt" && /^(separator|spacer|bullet|icon|logo|image|decorative|presentation)$/i.test(trimmed)) return true;
+	if (prop === "aria-label" && isTechnicalTerm(trimmed) && isSingleWord(trimmed)) return true;
+	return false;
+}
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Flatten a nested JSON object into dot-notation keys */
+function flattenKeys(obj, prefix = "") {
+	const keys = /* @__PURE__ */ new Set();
+	for (const [key, value] of Object.entries(obj)) {
+		const fullKey = prefix ? `${prefix}.${key}` : key;
+		if (value && typeof value === "object" && !Array.isArray(value)) {
+			const nested = flattenKeys(value, fullKey);
+			for (const k of nested) keys.add(k);
+		} else keys.add(fullKey);
+	}
+	return keys;
+}
+/** Find locale JSON files in the project */
+async function findLocaleFiles(rootDir) {
+	const candidates = [];
+	for (const dir of [
+		"messages",
+		"locales",
+		"i18n",
+		"public/locales",
+		"public/messages",
+		"public/i18n",
+		"src/locales",
+		"src/i18n",
+		"src/messages"
+	]) {
+		const absDir = join(rootDir, dir);
+		try {
+			if (!(await stat(absDir)).isDirectory()) continue;
+			const entries = await readdir(absDir);
+			for (const entry of entries) if (entry.endsWith(".json")) candidates.push(join(absDir, entry));
+		} catch {}
+	}
+	try {
+		const rootEntries = await readdir(rootDir);
+		const localePattern = /^(en|fr|de|es|pt|it|nl|ja|ko|zh|ru|ar|hi|tr|pl|cs|sv|da|no|fi|uk|he|th|vi|id)\.json$/i;
+		for (const entry of rootEntries) if (localePattern.test(entry)) candidates.push(join(rootDir, entry));
+	} catch {}
+	return candidates;
+}
+/** Load all locale files and return their data */
+async function loadLocales(rootDir) {
+	const localeFiles = await findLocaleFiles(rootDir);
+	const locales = [];
+	for (const filePath of localeFiles) try {
+		const content = await readFileContent(filePath);
+		const json = JSON.parse(content);
+		if (typeof json !== "object" || json === null || Array.isArray(json)) continue;
+		const localeName = (filePath.split("/").pop() ?? filePath.split("\\").pop() ?? "unknown").replace(/\.json$/, "");
+		const keys = flattenKeys(json);
+		locales.push({
+			locale: localeName,
+			keys,
+			filePath
+		});
+	} catch {}
+	return locales;
+}
+/** Extract translation keys from t() calls */
+function extractTranslationKeys(content) {
+	const keys = [];
+	const tCallPattern = /(?:\bt|i18n\.t|i18next\.t|useTranslations\(\s*['"][^'"]*['"]\s*\)\.t)\s*\(\s*['"`]([^'"`\s]+)['"`]\s*[,\)]/g;
+	let match;
+	while ((match = tCallPattern.exec(content)) !== null) keys.push({
+		key: match[1],
+		offset: match.index
+	});
+	return keys;
+}
+function detectMissingTranslationKeys(content, lines, filePath, locales) {
+	if (locales.length === 0) return [];
+	const results = [];
+	const extractedKeys = extractTranslationKeys(content);
+	for (const { key, offset } of extractedKeys) {
+		const missingIn = [];
+		for (const locale of locales) if (!locale.keys.has(key)) missingIn.push(locale.locale);
+		if (missingIn.length > 0) {
+			const lineInfo = findLineByOffset(lines, offset);
+			if (!lineInfo) continue;
+			const allMissing = missingIn.length === locales.length;
+			const message = allMissing ? `Translation key "${key}" not found in any locale file` : `Translation key "${key}" missing in locale(s): ${missingIn.join(", ")}`;
+			results.push(diag({
+				filePath,
+				rule: "i18n-lint/missing-translation-key",
+				severity: "warning",
+				message,
+				help: allMissing ? `Add key "${key}" to all locale files, or check for a typo in the translation key.` : `Add the missing key "${key}" to: ${missingIn.map((l) => `${l}.json`).join(", ")}`,
+				line: lineInfo.line,
+				column: lineInfo.text.indexOf(key) + 1 || lineInfo.col,
+				fixable: false,
+				detail: {
+					key,
+					missingLocales: missingIn,
+					allMissing
+				}
+			}));
+		}
+	}
+	return results;
+}
+/**
+* Detect components that import a specific locale string directly instead
+* of using the i18n system.
+* Pattern: importing from './ru.json' or hardcoded locale='ru'
+*/
+function detectLocaleMismatch(content, lines, filePath) {
+	const results = [];
+	for (const pattern of [/import\s+[^;]*\s+from\s+['"][^'"]*\/(locales|i18n|messages)\/(en|fr|de|es|pt|it|nl|ja|ko|zh|ru|ar|hi|tr|pl|cs|sv|da|no|fi|uk|he|th|vi|id)[^/]*\.json['"]/gi, /import\s+[^;]*\s+from\s+['"]\.\.?\/[^'"]*(en|fr|de|es|pt|it|nl|ja|ko|zh|ru|ar|hi|tr|pl|cs|sv|da|no|fi|uk|he|th|vi|id)\.json['"]/gi]) {
+		let match;
+		while ((match = pattern.exec(content)) !== null) {
+			const lineInfo = findLineByOffset(lines, match.index);
+			if (!lineInfo) continue;
+			const localeMatch = match[0].match(/(en|fr|de|es|pt|it|nl|ja|ko|zh|ru|ar|hi|tr|pl|cs|sv|da|no|fi|uk|he|th|vi|id)\.json/i);
+			const localeCode = localeMatch ? localeMatch[1] : "unknown";
+			results.push(diag({
+				filePath,
+				rule: "i18n-lint/locale-mismatch",
+				severity: "warning",
+				message: `Direct import from locale file "${localeCode}.json" — bypasses i18n system`,
+				help: "Use the i18n translation function (t()) instead of importing locale JSON directly. Direct imports tie the component to a specific language.",
+				line: lineInfo.line,
+				column: lineInfo.text.indexOf("import") + 1 || 1,
+				fixable: false,
+				suggestion: {
+					type: "refactor",
+					text: `import { useTranslation } from 'react-i18next';`,
+					confidence: .7,
+					reason: "Use the i18n hook instead of directly importing a locale file."
+				},
+				detail: {
+					localeCode,
+					importPath: match[0]
+				}
+			}));
+		}
+	}
+	const localePropPattern = /\blocale\s*=\s*['"](en|fr|de|es|pt|it|nl|ja|ko|zh|ru|ar|hi|tr|pl|cs|sv|da|no|fi|uk|he|th|vi|id)['"]/gi;
+	let propMatch;
+	while ((propMatch = localePropPattern.exec(content)) !== null) {
+		const lineInfo = findLineByOffset(lines, propMatch.index);
+		if (!lineInfo) continue;
+		const localeCode = propMatch[1];
+		const trimmedLine = lineInfo.text.trim();
+		if (/i18n|initReactI18next|createInstance|config/.test(trimmedLine)) continue;
+		results.push(diag({
+			filePath,
+			rule: "i18n-lint/locale-mismatch",
+			severity: "warning",
+			message: `Hardcoded locale prop: locale="${localeCode}" — should use i18n system`,
+			help: "Use the dynamic locale from the i18n context instead of hardcoding a specific language: locale={i18n.language}",
+			line: lineInfo.line,
+			column: lineInfo.text.indexOf("locale") + 1 || 1,
+			fixable: true,
+			suggestion: {
+				type: "replace",
+				text: `locale={i18n.language}`,
+				confidence: .65,
+				reason: "Use the i18n system's current language instead of hardcoding a specific locale."
+			},
+			detail: { localeCode }
+		}));
+	}
+	const requireLocalePattern = /require\s*\(\s*['"][^'"]*(en|fr|de|es|pt|it|nl|ja|ko|zh|ru|ar|hi|tr|pl|cs|sv|da|no|fi|uk|he|th|vi|id)\.json['"]\s*\)/gi;
+	while ((propMatch = requireLocalePattern.exec(content)) !== null) {
+		const lineInfo = findLineByOffset(lines, propMatch.index);
+		if (!lineInfo) continue;
+		const localeCode = propMatch[1];
+		results.push(diag({
+			filePath,
+			rule: "i18n-lint/locale-mismatch",
+			severity: "warning",
+			message: `require() of locale file "${localeCode}.json" — bypasses i18n system`,
+			help: "Use the i18n translation function instead of requiring locale JSON directly.",
+			line: lineInfo.line,
+			column: lineInfo.text.indexOf("require") + 1 || 1,
+			fixable: false,
+			detail: { localeCode }
+		}));
+	}
+	return results;
+}
+/**
+* Compare keys across locale files, report keys present in one locale
+* but missing in another.
+*/
+function detectUntranslatedLocale(locales, rootDir) {
+	if (locales.length < 2) return [];
+	const results = [];
+	const allKeys = /* @__PURE__ */ new Set();
+	for (const locale of locales) for (const key of locale.keys) allKeys.add(key);
+	for (const key of allKeys) {
+		const presentIn = [];
+		const missingIn = [];
+		for (const locale of locales) if (locale.keys.has(key)) presentIn.push(locale.locale);
+		else missingIn.push(locale.locale);
+		if (missingIn.length > 0 && presentIn.length > 0) {
+			const sourceLocale = locales.find((l) => l.keys.has(key));
+			if (!sourceLocale) continue;
+			const relPath = relative(rootDir, sourceLocale.filePath);
+			results.push(diag({
+				filePath: relPath,
+				rule: "i18n-lint/untranslated-locale",
+				severity: "info",
+				message: `Key "${key}" present in [${presentIn.join(", ")}] but missing in [${missingIn.join(", ")}]`,
+				help: `Add the translation for "${key}" to: ${missingIn.map((l) => `${l}.json`).join(", ")}`,
+				line: 1,
+				column: 1,
+				fixable: false,
+				detail: {
+					key,
+					presentLocales: presentIn,
+					missingLocales: missingIn
+				}
+			}));
+		}
+	}
+	return results;
+}
+async function analyzeFile(filePath, rootDir, locales, hardcodedStringsEnabled, validateKeysEnabled) {
+	const diagnostics = [];
+	const language = languageFromPath(filePath);
+	if (!language) return diagnostics;
+	if (language !== "typescript" && language !== "javascript") return diagnostics;
+	let content;
+	try {
+		content = await readFileContent(filePath);
+	} catch {
+		return diagnostics;
+	}
+	const lines = toLines(content);
+	const relPath = relative(rootDir, filePath);
+	const isJsx = isJsxFile(filePath);
+	if (hardcodedStringsEnabled && isJsx) diagnostics.push(...detectHardcodedStringJsx(content, lines, relPath));
+	if (hardcodedStringsEnabled && isJsx) diagnostics.push(...detectHardcodedStringProps(content, lines, relPath));
+	if (validateKeysEnabled) diagnostics.push(...detectMissingTranslationKeys(content, lines, relPath, locales));
+	diagnostics.push(...detectLocaleMismatch(content, lines, relPath));
+	return diagnostics;
+}
+const i18nLintEngine = {
+	name: "i18n-lint",
+	description: "Internationalization linting engine. Detects hardcoded strings in JSX text and props, missing translation keys, direct locale imports bypassing the i18n system, and untranslated keys across locale files.",
+	supportedLanguages: ["typescript", "javascript"],
+	async run(context) {
+		const start = performance.now();
+		const files = context.files ?? [];
+		if (files.length === 0) return {
+			engine: "i18n-lint",
+			diagnostics: [],
+			elapsed: performance.now() - start,
+			skipped: true,
+			skipReason: "No files to scan (context.files is empty)"
+		};
+		const { hardcodedStrings, validateKeys } = context.config.i18n;
+		const locales = await loadLocales(context.rootDirectory);
+		const allDiagnostics = [];
+		const batchSize = 20;
+		for (let i = 0; i < files.length; i += batchSize) {
+			const batch = files.slice(i, i + batchSize);
+			const results = await Promise.all(batch.map((filePath) => analyzeFile(filePath, context.rootDirectory, locales, hardcodedStrings, validateKeys)));
+			for (const diags of results) allDiagnostics.push(...diags);
+		}
+		if (validateKeys && locales.length >= 2) allDiagnostics.push(...detectUntranslatedLocale(locales, context.rootDirectory));
+		return {
+			engine: "i18n-lint",
+			diagnostics: allDiagnostics,
+			elapsed: performance.now() - start,
+			skipped: false
+		};
+	}
+};
+
+//#endregion
+export { i18nLintEngine };