translint 0.2.0

package/dist/index.js

@@ -0,0 +1,678 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  analyzeProject: () => analyzeProject,
+  computeScore: () => computeScore,
+  loadConfig: () => loadConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/analyze.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+
+// src/core/localeDiscovery.ts
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+
+// src/utils/flatten.ts
+function flattenJson(value, prefix = "", out = /* @__PURE__ */ new Map()) {
+  for (const [key, nested] of Object.entries(value)) {
+    const nextKey = prefix ? `${prefix}.${key}` : key;
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+      flattenJson(nested, nextKey, out);
+    } else {
+      out.set(nextKey, nested);
+    }
+  }
+  return out;
+}
+
+// src/core/localeDiscovery.ts
+function discoverLocales(config) {
+  const dir = import_path.default.resolve(config.projectRoot, config.locales.dir);
+  const extension = config.locales.extension || ".json";
+  const fileName = config.locales.fileName || "trad";
+  if (!import_fs.default.existsSync(dir)) {
+    throw new Error(`Locales directory not found: ${dir}`);
+  }
+  const entries = import_fs.default.readdirSync(dir, { withFileTypes: true });
+  const localeFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(extension)).map((entry) => ({
+    locale: import_path.default.basename(entry.name, extension),
+    path: import_path.default.join(dir, entry.name)
+  }));
+  if (localeFiles.length > 0) {
+    return localeFiles.map((file) => {
+      const content = JSON.parse(import_fs.default.readFileSync(file.path, "utf8"));
+      return {
+        locale: file.locale,
+        path: file.path,
+        content,
+        flat: flattenJson(content)
+      };
+    });
+  }
+  const localeFolders = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  return localeFolders.map((locale) => {
+    const localePath = import_path.default.join(dir, locale, `${fileName}${extension}`);
+    if (!import_fs.default.existsSync(localePath)) {
+      return null;
+    }
+    const content = JSON.parse(import_fs.default.readFileSync(localePath, "utf8"));
+    return {
+      locale,
+      path: localePath,
+      content,
+      flat: flattenJson(content)
+    };
+  }).filter((entry) => entry !== null);
+}
+
+// src/core/sourceDiscovery.ts
+var import_fast_glob = __toESM(require("fast-glob"));
+async function discoverSourceFiles(config) {
+  const sources = config.source.length ? config.source : ["src"];
+  const patterns = sources.map((entry) => buildGlob(entry));
+  const entries = await (0, import_fast_glob.default)(patterns, {
+    cwd: config.projectRoot,
+    ignore: config.ignore.map((value) => toPosix(value)),
+    absolute: true
+  });
+  return entries;
+}
+function buildGlob(entry) {
+  const normalized = toPosix(entry);
+  if (normalized.includes("*")) {
+    return normalized;
+  }
+  const trimmed = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+  return `${trimmed}/**/*.{ts,tsx,js,jsx,vue,svelte,html}`;
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+
+// src/core/codeUsage.ts
+var import_typescript = __toESM(require("typescript"));
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+function extractCodeUsages(filePath, content, config) {
+  const extension = filePath.slice(filePath.lastIndexOf("."));
+  if (!SUPPORTED_EXTENSIONS.has(extension)) {
+    return [];
+  }
+  const sourceFile = import_typescript.default.createSourceFile(
+    filePath,
+    content,
+    import_typescript.default.ScriptTarget.ES2020,
+    true,
+    extension === ".tsx" || extension === ".jsx" ? import_typescript.default.ScriptKind.TSX : import_typescript.default.ScriptKind.TS
+  );
+  const usages = [];
+  const functions = new Set(config.patterns.functions);
+  const visit = (node) => {
+    if (import_typescript.default.isCallExpression(node)) {
+      const calleeName = getCalleeName(node.expression);
+      if (calleeName && functions.has(calleeName)) {
+        const arg = node.arguments[0];
+        if (arg) {
+          const literal = getLiteralText(arg);
+          const { line, character } = sourceFile.getLineAndCharacterOfPosition(arg.getStart());
+          usages.push({
+            key: literal ?? "",
+            file: filePath,
+            line: line + 1,
+            column: character + 1,
+            dynamic: literal === null,
+            pattern: calleeName
+          });
+        }
+      }
+    }
+    import_typescript.default.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return usages.filter((usage) => usage.key || usage.dynamic);
+}
+function extractLiteralUsages(filePath, content, prefix) {
+  if (!prefix) {
+    return [];
+  }
+  const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const expression = new RegExp(`(["'\`])(${escapedPrefix}[A-Za-z0-9_.-]+)\\1`, "g");
+  const usages = [];
+  let match;
+  while ((match = expression.exec(content)) !== null) {
+    const fullKey = match[2];
+    const before = content.slice(0, match.index);
+    const lines = before.split("\n");
+    const line = lines.length;
+    const column = lines[lines.length - 1].length + 1;
+    usages.push({
+      key: fullKey,
+      file: filePath,
+      line,
+      column,
+      dynamic: false,
+      pattern: "literal"
+    });
+  }
+  return usages;
+}
+function getCalleeName(expression) {
+  if (import_typescript.default.isIdentifier(expression)) {
+    return expression.text;
+  }
+  if (import_typescript.default.isPropertyAccessExpression(expression)) {
+    const left = getCalleeName(expression.expression);
+    if (!left) {
+      return expression.name.text;
+    }
+    return `${left}.${expression.name.text}`;
+  }
+  return null;
+}
+function getLiteralText(expression) {
+  if (import_typescript.default.isStringLiteral(expression)) {
+    return expression.text;
+  }
+  if (import_typescript.default.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  return null;
+}
+
+// src/core/analyze.ts
+async function analyzeProject(params) {
+  const config = applyCliOverrides(params.config, params.cliOptions);
+  const translationFiles = discoverLocales(config);
+  const sourceFiles = await discoverSourceFiles(config);
+  const codeUsages = collectCodeUsages(sourceFiles, config);
+  const issues = collectIssues(translationFiles, codeUsages, config, params.cliOptions);
+  const namespaces = buildNamespaces(translationFiles);
+  const summary = buildSummary(translationFiles, codeUsages, issues);
+  return {
+    config,
+    translationFiles,
+    codeUsages,
+    issues,
+    summary,
+    namespaces
+  };
+}
+function applyCliOverrides(config, cli) {
+  if (!cli) {
+    return config;
+  }
+  return {
+    ...config,
+    source: cli.source && cli.source.length ? cli.source : config.source,
+    locales: {
+      ...config.locales,
+      dir: cli.localesDir ?? config.locales.dir,
+      sourceLang: cli.sourceLang ?? config.locales.sourceLang
+    },
+    ignore: cli.ignore && cli.ignore.length ? [...config.ignore, ...cli.ignore] : config.ignore
+  };
+}
+function collectCodeUsages(files, config) {
+  const usages = [];
+  for (const file of files) {
+    const content = import_fs2.default.readFileSync(file, "utf8");
+    const fileUsages = extractCodeUsages(file, content, config);
+    const literalUsages = extractLiteralUsages(file, content, config.patterns.prefix);
+    usages.push(...fileUsages, ...literalUsages);
+  }
+  const normalized = usages.map((usage) => {
+    const prefix = config.patterns.prefix;
+    if (prefix && usage.key.startsWith(prefix)) {
+      return { ...usage, key: usage.key.slice(prefix.length) };
+    }
+    return usage;
+  });
+  return dedupeUsages(normalized);
+}
+function dedupeUsages(usages) {
+  const seen = /* @__PURE__ */ new Set();
+  return usages.filter((usage) => {
+    const token = `${usage.key}:${usage.file}:${usage.line}:${usage.column}:${usage.dynamic}`;
+    if (seen.has(token)) {
+      return false;
+    }
+    seen.add(token);
+    return true;
+  });
+}
+function collectIssues(translations, codeUsages, config, cli) {
+  const issues = [];
+  const locales = translations.map((file) => file.locale);
+  const reference = translations.find((file) => file.locale === config.locales.sourceLang);
+  const referenceKeys = reference ? new Set(reference.flat.keys()) : /* @__PURE__ */ new Set();
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const file of translations) {
+    for (const key of file.flat.keys()) {
+      allKeys.add(key);
+    }
+  }
+  for (const locale of locales) {
+    const file = translations.find((entry) => entry.locale === locale);
+    if (!file) {
+      continue;
+    }
+    const keysToCheck = reference ? referenceKeys : allKeys;
+    for (const key of keysToCheck) {
+      if (!file.flat.has(key)) {
+        issues.push({
+          type: "missing",
+          severity: "high",
+          key,
+          locale,
+          message: `Missing key "${key}" in ${locale}`
+        });
+      }
+    }
+    if (reference) {
+      for (const key of file.flat.keys()) {
+        if (!referenceKeys.has(key)) {
+          issues.push({
+            type: "extra",
+            severity: "medium",
+            key,
+            locale: file.locale,
+            message: `Extra key "${key}" in ${file.locale}`
+          });
+        }
+      }
+    }
+  }
+  if (config.rules.detectUnused) {
+    const usedKeys = new Set(codeUsages.filter((usage) => !usage.dynamic).map((u) => u.key));
+    const referenceKeys2 = reference ? Array.from(reference.flat.keys()) : Array.from(allKeys);
+    for (const key of referenceKeys2) {
+      if (!usedKeys.has(key)) {
+        issues.push({
+          type: "unused",
+          severity: "low",
+          key,
+          message: `Unused key "${key}"`
+        });
+      }
+    }
+  }
+  if (config.rules.detectEmpty || config.rules.detectNull || config.rules.detectSameAsKey) {
+    for (const file of translations) {
+      for (const [key, value] of file.flat.entries()) {
+        if (config.rules.detectNull && value === null) {
+          issues.push({
+            type: "null",
+            severity: "medium",
+            key,
+            locale: file.locale,
+            message: `Null value for "${key}" in ${file.locale}`
+          });
+        }
+        if (config.rules.detectEmpty && value === "") {
+          issues.push({
+            type: "empty",
+            severity: "medium",
+            key,
+            locale: file.locale,
+            message: `Empty value for "${key}" in ${file.locale}`
+          });
+        }
+        if (config.rules.detectSameAsKey && typeof value === "string" && value.trim() === key) {
+          issues.push({
+            type: "same-as-key",
+            severity: "low",
+            key,
+            locale: file.locale,
+            message: `Value equals key for "${key}" in ${file.locale}`
+          });
+        }
+      }
+    }
+  }
+  if (config.rules.detectDuplicateTranslations) {
+    for (const key of allKeys) {
+      const values = translations.map((file) => file.flat.get(key)).filter((value) => typeof value === "string");
+      if (values.length === locales.length && new Set(values).size === 1) {
+        issues.push({
+          type: "duplicate-value",
+          severity: "low",
+          key,
+          message: `Same translation for all locales: "${key}"`
+        });
+      }
+    }
+  }
+  if (config.rules.detectPlaceholderMismatch) {
+    for (const key of allKeys) {
+      const placeholderMap = /* @__PURE__ */ new Map();
+      for (const file of translations) {
+        const value = file.flat.get(key);
+        if (typeof value === "string") {
+          placeholderMap.set(file.locale, extractPlaceholders(value));
+        }
+      }
+      const reference2 = placeholderMap.get(config.locales.sourceLang) ?? [];
+      for (const [locale, placeholders] of placeholderMap.entries()) {
+        if (!samePlaceholders(reference2, placeholders)) {
+          issues.push({
+            type: "placeholder",
+            severity: "medium",
+            key,
+            locale,
+            message: `Placeholder mismatch for "${key}" in ${locale}`
+          });
+        }
+      }
+    }
+  }
+  if (config.rules.detectStructureMismatch) {
+    const structure = /* @__PURE__ */ new Map();
+    for (const file of translations) {
+      structure.set(file.locale, new Set(file.flat.keys()));
+    }
+    for (const key of allKeys) {
+      for (const locale of locales) {
+        const localeKeys = structure.get(locale);
+        if (!localeKeys) continue;
+        if (!localeKeys.has(key) && localeKeysHasPrefix(localeKeys, key)) {
+          issues.push({
+            type: "structure",
+            severity: "medium",
+            key,
+            locale,
+            message: `Structure mismatch around "${key}" in ${locale}`
+          });
+        }
+      }
+    }
+  }
+  if (cli?.includeDynamicWarnings) {
+    for (const usage of codeUsages.filter((usage2) => usage2.dynamic)) {
+      issues.push({
+        type: "dynamic",
+        severity: "low",
+        key: usage.key,
+        file: usage.file,
+        message: `Dynamic key usage in ${import_path2.default.basename(usage.file)}`
+      });
+    }
+  }
+  return issues;
+}
+function buildSummary(translations, codeUsages, issues) {
+  const summary = {
+    locales: translations.map((file) => file.locale),
+    totalKeys: new Set(translations.flatMap((file) => Array.from(file.flat.keys()))).size,
+    totalUsages: codeUsages.length,
+    totalIssues: issues.length,
+    missingKeys: 0,
+    extraKeys: 0,
+    unusedKeys: 0,
+    emptyValues: 0,
+    nullValues: 0,
+    sameAsKey: 0,
+    placeholderIssues: 0,
+    duplicateValueIssues: 0,
+    structureIssues: 0,
+    dynamicWarnings: 0
+  };
+  for (const issue of issues) {
+    switch (issue.type) {
+      case "missing":
+        summary.missingKeys += 1;
+        break;
+      case "extra":
+        summary.extraKeys += 1;
+        break;
+      case "unused":
+        summary.unusedKeys += 1;
+        break;
+      case "empty":
+        summary.emptyValues += 1;
+        break;
+      case "null":
+        summary.nullValues += 1;
+        break;
+      case "same-as-key":
+        summary.sameAsKey += 1;
+        break;
+      case "placeholder":
+        summary.placeholderIssues += 1;
+        break;
+      case "duplicate-value":
+        summary.duplicateValueIssues += 1;
+        break;
+      case "structure":
+        summary.structureIssues += 1;
+        break;
+      case "dynamic":
+        summary.dynamicWarnings += 1;
+        break;
+      default:
+        break;
+    }
+  }
+  return summary;
+}
+function buildNamespaces(translations) {
+  const namespaces = {};
+  for (const file of translations) {
+    for (const key of file.flat.keys()) {
+      const prefix = key.includes(".") ? key.split(".")[0] : "root";
+      namespaces[prefix] = (namespaces[prefix] ?? 0) + 1;
+    }
+  }
+  return namespaces;
+}
+function extractPlaceholders(value) {
+  const placeholders = /* @__PURE__ */ new Set();
+  const mustache = value.match(/\{\{(\w+)\}\}/g) ?? [];
+  const brace = value.match(/\{(\w+)\}/g) ?? [];
+  const percent = value.match(/%[sdif]/g) ?? [];
+  for (const token of mustache) placeholders.add(token);
+  for (const token of brace) placeholders.add(token);
+  for (const token of percent) placeholders.add(token);
+  return Array.from(placeholders).sort();
+}
+function samePlaceholders(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function localeKeysHasPrefix(keys, key) {
+  const prefix = `${key}.`;
+  for (const candidate of keys) {
+    if (candidate.startsWith(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/config/loadConfig.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  projectRoot: process.cwd(),
+  source: ["src"],
+  locales: {
+    dir: "src/i18n",
+    extension: ".json",
+    fileName: "trad",
+    sourceLang: "en"
+  },
+  patterns: {
+    prefix: "trad.",
+    functions: ["t", "i18n.t", "translate.instant", "this.translate.instant"]
+  },
+  ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/coverage/**"],
+  rules: {
+    detectEmpty: true,
+    detectNull: true,
+    detectSameAsKey: true,
+    detectUnused: true,
+    detectDuplicateTranslations: true,
+    detectPlaceholderMismatch: true,
+    detectStructureMismatch: true
+  },
+  report: {
+    title: "Translint Report",
+    darkMode: true
+  },
+  fix: {
+    strategy: "todo",
+    placeholder: "TODO_TRANSLATE",
+    sort: true
+  }
+};
+
+// src/utils/merge.ts
+function mergeDeep(base, override) {
+  if (override === void 0 || override === null) {
+    return base;
+  }
+  if (Array.isArray(base) && Array.isArray(override)) {
+    return override;
+  }
+  if (isObject(base) && isObject(override)) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+      const current = base[key];
+      result[key] = mergeDeep(current, value);
+    }
+    return result;
+  }
+  return override;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/config/loadConfig.ts
+var CONFIG_FILES = [
+  "i18n-checker.config.js",
+  "i18n-checker.config.cjs",
+  "i18n-checker.config.mjs",
+  "i18n-checker.config.json",
+  "i18n-checker.config.ts"
+];
+async function loadConfig(configPath) {
+  if (configPath) {
+    return mergeDeep(DEFAULT_CONFIG, await loadConfigFile(configPath));
+  }
+  for (const fileName of CONFIG_FILES) {
+    const candidate = import_path3.default.resolve(process.cwd(), fileName);
+    if (import_fs3.default.existsSync(candidate)) {
+      return mergeDeep(DEFAULT_CONFIG, await loadConfigFile(candidate));
+    }
+  }
+  const packageJsonPath = import_path3.default.resolve(process.cwd(), "package.json");
+  if (import_fs3.default.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(import_fs3.default.readFileSync(packageJsonPath, "utf8"));
+    if (pkg.i18nChecker) {
+      return mergeDeep(DEFAULT_CONFIG, pkg.i18nChecker);
+    }
+  }
+  return DEFAULT_CONFIG;
+}
+async function loadConfigFile(filePath) {
+  const ext = import_path3.default.extname(filePath);
+  if (ext === ".json") {
+    return JSON.parse(import_fs3.default.readFileSync(filePath, "utf8"));
+  }
+  if (ext === ".ts") {
+    try {
+      await import("ts-node/register/transpile-only");
+    } catch (error) {
+      throw new Error(
+        "Config file is TypeScript but ts-node is not installed. Install ts-node or use .js/.json."
+      );
+    }
+  }
+  const resolved = import_path3.default.isAbsolute(filePath) ? filePath : import_path3.default.resolve(process.cwd(), filePath);
+  const imported = require(resolved);
+  return imported.default ?? imported;
+}
+
+// src/scoring/score.ts
+function computeScore(analysis) {
+  const { summary } = analysis;
+  const completeness = scorePart(summary.missingKeys + summary.extraKeys, summary.totalKeys);
+  const usage = scorePart(summary.unusedKeys, summary.totalKeys);
+  const consistency = scorePart(summary.placeholderIssues + summary.structureIssues, summary.totalKeys);
+  const quality = scorePart(
+    summary.emptyValues + summary.nullValues + summary.sameAsKey + summary.duplicateValueIssues,
+    summary.totalKeys
+  );
+  const total = Math.round(
+    completeness * 0.35 + consistency * 0.25 + usage * 0.2 + quality * 0.2
+  );
+  const level = total >= 90 ? "excellent" : total >= 75 ? "good" : total >= 60 ? "average" : "critical";
+  const notes = [];
+  if (summary.missingKeys > 0) notes.push("Fix missing keys across locales.");
+  if (summary.unusedKeys > 0) notes.push("Clean unused translation keys.");
+  if (summary.placeholderIssues > 0) notes.push("Align placeholders between languages.");
+  if (summary.emptyValues > 0 || summary.nullValues > 0)
+    notes.push("Fill empty or null translations.");
+  return {
+    total,
+    level,
+    breakdown: {
+      completeness,
+      consistency,
+      usage,
+      quality
+    },
+    notes
+  };
+}
+function scorePart(issues, total) {
+  if (total === 0) return 100;
+  const ratio = Math.max(0, Math.min(1, 1 - issues / total));
+  return Math.round(ratio * 100);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeProject,
+  computeScore,
+  loadConfig
+});