intor-cli 0.0.13 → 0.0.14

package/README.md

@@ -1,11 +1,5 @@
 <h1 align="center">intor-cli</h1>
 
-<div align="center">
-  
-CLI tool for intor.
-
-</div>
-
 <div align="center">
 
 [![NPM version](https://img.shields.io/npm/v/intor-cli?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/intor-cli)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intor-cli",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "The Intor CLI",
   "author": "Yiming Liao",
   "homepage": "https://github.com/yiming-liao/intor-cli#readme",

package/src/core/extract-usages/collectors/collect-trans-usages.ts

@@ -0,0 +1,69 @@
+import type { TransUsage } from "../types";
+import type { SourceFile } from "ts-morph";
+import { Node, SyntaxKind } from "ts-morph";
+import { isStaticStringLiteral } from "./utils/is-static-string-literal";
+
+const COMPONENT_NAME = "Trans";
+const KEY_PROPERTY_NAME = "i18nKey";
+
+/**
+ * Collect static translation key usages from <Trans /> components
+ * within a single source file.
+ */
+export function collectTransUsages(sourceFile: SourceFile): TransUsage[] {
+  const usages: TransUsage[] = [];
+
+  sourceFile.forEachDescendant((node) => {
+    // ------------------------------------------------------------
+    // Match <Trans ... /> or <Trans ...></Trans>
+    // ------------------------------------------------------------
+    if (
+      !node.isKind(SyntaxKind.JsxSelfClosingElement) &&
+      !node.isKind(SyntaxKind.JsxOpeningElement)
+    ) {
+      return;
+    }
+
+    const tagName = node.getTagNameNode()?.getText();
+    if (tagName !== COMPONENT_NAME) return;
+
+    // ------------------------------------------------------------
+    // Resolve i18nKey attribute
+    // ------------------------------------------------------------
+    const i18nKeyAttr = node
+      .getAttributes()
+      .find(
+        (attr) =>
+          attr.isKind(SyntaxKind.JsxAttribute) &&
+          attr.getNameNode().getText() === KEY_PROPERTY_NAME,
+      );
+
+    if (!i18nKeyAttr || !Node.isJsxAttribute(i18nKeyAttr)) return;
+
+    const initializer = i18nKeyAttr.getInitializer();
+    if (!initializer) return;
+
+    // Support:
+    //   <Trans i18nKey="home.title" />
+    //   <Trans i18nKey={"home.title"} />
+    const expr = initializer.isKind(SyntaxKind.JsxExpression)
+      ? initializer.getExpression()
+      : initializer;
+    if (!isStaticStringLiteral(expr)) return;
+    const literal = expr;
+
+    // ------------------------------------------------------------
+    // Source location
+    // ------------------------------------------------------------
+    const pos = sourceFile.getLineAndColumnAtPos(literal.getStart());
+
+    usages.push({
+      key: literal.getLiteralText(),
+      file: sourceFile.getFilePath(),
+      line: pos.line,
+      column: pos.column,
+    });
+  });
+
+  return usages;
+}

package/src/core/extract-usages/collectors/index.ts

@@ -3,3 +3,4 @@ export { collectKeyUsages } from "./collect-key-usages";
 export { collectReplacementUsages } from "./collect-replacement-usages";
 export { collectRichUsages } from "./collect-rich-usages";
 export { collectPreKeys } from "./collect-pre-keys";
+export { collectTransUsages } from "./collect-trans-usages";

package/src/core/extract-usages/extract-usages-from-source-file.ts

@@ -1,4 +1,11 @@
-import type { ExtractedUsages, PreKeyMap } from "./types";
+import type {
+  ExtractedUsages,
+  KeyUsage,
+  PreKeyMap,
+  PreKeyUsage,
+  ReplacementUsage,
+  RichUsage,
+} from "./types";
 import type { SourceFile } from "ts-morph";
 import {
   collectTranslatorBindings,
@@ -6,6 +13,7 @@ import {
   collectReplacementUsages,
   collectRichUsages,
   collectPreKeys,
+  collectTransUsages,
 } from "./collectors";
 
 function attachPreKey<T extends { localName: string; preKey?: string }>(
@@ -25,48 +33,60 @@ export function extractUsagesFromSourceFile(
   sourceFile: SourceFile,
 ): ExtractedUsages {
   // -----------------------------------------------------------------------
-  // Translator binding
+  // Trans component usages (independent of translator bindings)
   // -----------------------------------------------------------------------
-  const translatorBindingMap = collectTranslatorBindings(sourceFile);
-  if (translatorBindingMap.size === 0) {
-    return { preKey: [], key: [], replacement: [], rich: [] };
-  }
+  const transUsages = collectTransUsages(sourceFile);
 
   // -----------------------------------------------------------------------
-  // Key usages
+  // Translator binding (function-based APIs)
   // -----------------------------------------------------------------------
-  const keyUsages = collectKeyUsages(sourceFile, translatorBindingMap);
+  const translatorBindingMap = collectTranslatorBindings(sourceFile);
 
-  // -----------------------------------------------------------------------
-  // Replacement usages
-  // -----------------------------------------------------------------------
-  const replacementUsages = collectReplacementUsages(
-    sourceFile,
-    translatorBindingMap,
-  );
+  // Prepare defaults
+  let keyUsages: KeyUsage[] = [];
+  let replacementUsages: ReplacementUsage[] = [];
+  let richUsages: RichUsage[] = [];
+  let preKeyUsages: PreKeyUsage[] = [];
 
-  // -----------------------------------------------------------------------
-  // Rich usages
-  // -----------------------------------------------------------------------
-  const richUsages = collectRichUsages(sourceFile, translatorBindingMap);
+  if (translatorBindingMap.size > 0) {
+    // ---------------------------------------------------------------------
+    // Key usages
+    // ---------------------------------------------------------------------
+    keyUsages = collectKeyUsages(sourceFile, translatorBindingMap);
 
-  // -----------------------------------------------------------------------
-  // PreKey values
-  // -----------------------------------------------------------------------
-  const { preKeyMap, usages } = collectPreKeys(
-    sourceFile,
-    translatorBindingMap,
-  );
+    // ---------------------------------------------------------------------
+    // Replacement usages
+    // ---------------------------------------------------------------------
+    replacementUsages = collectReplacementUsages(
+      sourceFile,
+      translatorBindingMap,
+    );
+
+    // ---------------------------------------------------------------------
+    // Rich usages
+    // ---------------------------------------------------------------------
+    richUsages = collectRichUsages(sourceFile, translatorBindingMap);
 
-  // Attach preKey to all usages that support it
-  attachPreKey(keyUsages, preKeyMap);
-  attachPreKey(replacementUsages, preKeyMap);
-  attachPreKey(richUsages, preKeyMap);
+    // ---------------------------------------------------------------------
+    // PreKey values
+    // ---------------------------------------------------------------------
+    const { preKeyMap, usages } = collectPreKeys(
+      sourceFile,
+      translatorBindingMap,
+    );
+
+    attachPreKey(keyUsages, preKeyMap);
+    attachPreKey(replacementUsages, preKeyMap);
+    attachPreKey(richUsages, preKeyMap);
+
+    preKeyUsages = usages;
+  }
 
   return {
-    preKey: usages,
+    preKey: preKeyUsages,
     key: keyUsages,
     replacement: replacementUsages,
     rich: richUsages,
+    trans: transUsages,
   };
 }

package/src/core/extract-usages/extract-usages.ts

@@ -6,7 +6,10 @@ import { loadSourceFilesFromTsconfig } from "./load-source-files-from-tscofnig";
 
 /** Check whether a file-level extraction produced any meaningful usage */
 const isEmpty = (u: ExtractedUsages) =>
-  u.key.length === 0 && u.replacement.length === 0 && u.rich.length === 0;
+  u.key.length === 0 &&
+  u.replacement.length === 0 &&
+  u.rich.length === 0 &&
+  u.trans.length === 0;
 
 export interface ExtractUsagesOptions {
   tsconfigPath?: string;
@@ -25,6 +28,7 @@ export function extractUsages(options?: ExtractUsagesOptions): ExtractedUsages {
     key: [],
     replacement: [],
     rich: [],
+    trans: [],
   };
 
   // Debug counters
@@ -52,6 +56,7 @@ export function extractUsages(options?: ExtractUsagesOptions): ExtractedUsages {
     result.key.push(...partial.key);
     result.replacement.push(...partial.replacement);
     result.rich.push(...partial.rich);
+    result.trans.push(...partial.trans);
   }
 
   // Debug summary

package/src/core/extract-usages/types.ts

@@ -52,10 +52,16 @@ export interface RichUsage extends TranslatorBinding, SourceLocation {
   preKey?: string;
 }
 
+export interface TransUsage extends SourceLocation {
+  key: string;
+  configKey?: string;
+}
+
 /** Aggregated static translator usages extracted from a project. */
 export interface ExtractedUsages {
   preKey: PreKeyUsage[];
   key: KeyUsage[];
   replacement: ReplacementUsage[];
   rich: RichUsage[];
+  trans: TransUsage[];
 }

package/src/features/check/check.ts

@@ -58,6 +58,9 @@ export async function check(extractOptions?: ExtractUsagesOptions) {
         rich: usages.rich.filter(
           (u) => resolveConfigKey(u.configKey, defaultConfigKey) === configKey,
         ),
+        trans: usages.trans.filter(
+          (u) => resolveConfigKey(u.configKey, defaultConfigKey) === configKey,
+        ),
       };
 
       // Diagnostic

package/src/features/check/diagnostics/collect.ts

@@ -1,5 +1,6 @@
 import type { Diagnostic } from "./types";
 import type { ExtractedUsages, InferredSchemas } from "../../../core";
+import type { KeyUsageLike } from "./rules/key/types";
 import { enforceMissingReplacements } from "./rules/enforce-missing-replacements";
 import { enforceMissingRich } from "./rules/enforce-missing-rich";
 import { keyEmpty, keyNotFound } from "./rules/key";
@@ -18,13 +19,24 @@ export function collectDiagnostics(
 ) {
   const diagnostics: Diagnostic[] = [];
 
+  const allKeyUsages: KeyUsageLike[] = [
+    ...usages.key.map((u) => ({ ...u, origin: u.method })),
+    ...usages.trans.map((u) => ({
+      origin: "<Trans />",
+      key: u.key,
+      file: u.file,
+      line: u.line,
+      column: u.column,
+    })),
+  ];
+
   // PreKey
   for (const usage of usages.preKey) {
     diagnostics.push(...preKeyNotFound(usage, messagesSchema));
   }
 
   // Key
-  for (const usage of usages.key) {
+  for (const usage of allKeyUsages) {
     diagnostics.push(...keyNotFound(usage, messagesSchema), ...keyEmpty(usage));
   }
 

package/src/features/check/diagnostics/group.ts

@@ -8,16 +8,8 @@ export function groupDiagnostics(diagnostics: Diagnostic[]): DiagnosticGroup[] {
   const map = new Map<string, DiagnosticGroup>();
 
   for (const diagnostic of diagnostics) {
-    const {
-      severity,
-      factory,
-      method,
-      message,
-      messageKey,
-      file,
-      line,
-      column,
-    } = diagnostic;
+    const { severity, origin, message, messageKey, file, line, column } =
+      diagnostic;
 
     // --------------------------------------------------
     // Grouping key
@@ -25,15 +17,14 @@ export function groupDiagnostics(diagnostics: Diagnostic[]): DiagnosticGroup[] {
     // - Fallback to exact source location
     // --------------------------------------------------
     const groupId = messageKey
-      ? `${file}::${messageKey}::${diagnostic.method}`
+      ? `${file}::${messageKey}::${origin}`
       : `${file}::${line}:${column}`;
 
     // Initialize group if not exists
     if (!map.has(groupId)) {
       map.set(groupId, {
         severity,
-        factory,
-        method,
+        origin,
         messageKey,
         problems: [],
         file,

package/src/features/check/diagnostics/rules/enforce-missing-replacements.ts

@@ -41,7 +41,7 @@ export function enforceMissingReplacements(
 
   diagnostics.push({
     severity: "warn",
-    method,
+    origin: method,
     messageKey: keyPath,
     code: DIAGNOSTIC_MESSAGES.REPLACEMENTS_MISSING.code,
     message: DIAGNOSTIC_MESSAGES.REPLACEMENTS_MISSING.message(expected),

package/src/features/check/diagnostics/rules/enforce-missing-rich.ts

@@ -41,7 +41,7 @@ export function enforceMissingRich(
 
   diagnostics.push({
     severity: "warn",
-    method,
+    origin: method,
     messageKey: keyPath,
     code: DIAGNOSTIC_MESSAGES.RICH_MISSING.code,
     message: DIAGNOSTIC_MESSAGES.RICH_MISSING.message(expected),

package/src/features/check/diagnostics/rules/key/empty.ts

@@ -1,4 +1,4 @@
-import type { KeyUsage } from "../../../../../core";
+import type { KeyUsageLike } from "./types";
 import type { Diagnostic } from "../../types";
 import { DIAGNOSTIC_MESSAGES } from "../../messages";
 
@@ -12,14 +12,14 @@ import { DIAGNOSTIC_MESSAGES } from "../../messages";
  * t("")
  * ```
  */
-export function keyEmpty(usage: KeyUsage): Diagnostic[] {
-  const { method, key, file, line, column } = usage;
+export function keyEmpty(usage: KeyUsageLike): Diagnostic[] {
+  const { origin, key, file, line, column } = usage;
 
   if (!key) {
     return [
       {
         severity: "warn",
-        method,
+        origin,
         messageKey: key,
         code: DIAGNOSTIC_MESSAGES.KEY_EMPTY.code,
         message: DIAGNOSTIC_MESSAGES.KEY_EMPTY.message(),

package/src/features/check/diagnostics/rules/key/not-found.ts

@@ -1,4 +1,5 @@
-import type { KeyUsage, InferNode } from "../../../../../core";
+import type { KeyUsageLike } from "./types";
+import type { InferNode } from "../../../../../core";
 import type { Diagnostic } from "../../types";
 import { DIAGNOSTIC_MESSAGES } from "../../messages";
 import { getSchemaNodeAtPath } from "../../utils/get-schema-node-at-path";
@@ -15,10 +16,10 @@ import { resolveKeyPath } from "../../utils/resolve-key-path";
  * ```
  */
 export function keyNotFound(
-  usage: KeyUsage,
+  usage: KeyUsageLike,
   messagesSchema: InferNode,
 ): Diagnostic[] {
-  const { method, key, preKey, file, line, column } = usage;
+  const { origin, key, preKey, file, line, column } = usage;
 
   if (!key) return [];
 
@@ -27,7 +28,7 @@ export function keyNotFound(
     return [
       {
         severity: "warn",
-        method,
+        origin,
         messageKey: key,
         code: DIAGNOSTIC_MESSAGES.KEY_NOT_FOUND.code,
         message: DIAGNOSTIC_MESSAGES.KEY_NOT_FOUND.message(),

package/src/features/check/diagnostics/rules/key/types.ts

@@ -0,0 +1,8 @@
+import type { KeyUsage } from "../../../../../core";
+
+export interface KeyUsageLike extends Omit<
+  KeyUsage,
+  "localName" | "factory" | "method"
+> {
+  origin: string;
+}

package/src/features/check/diagnostics/rules/pre-key/not-found.ts

@@ -25,7 +25,7 @@ export function preKeyNotFound(
     return [
       {
         severity: "warn",
-        factory,
+        origin: factory,
         messageKey: preKey,
         code: DIAGNOSTIC_MESSAGES.PRE_KEY_NOT_FOUND.code,
         message: DIAGNOSTIC_MESSAGES.PRE_KEY_NOT_FOUND.message(),

package/src/features/check/diagnostics/rules/replacement/missing.ts

@@ -32,7 +32,7 @@ export function replacementsMissing(
     return [
       {
         severity: "warn",
-        method,
+        origin: method,
         messageKey: keyPath,
         code: DIAGNOSTIC_MESSAGES.REPLACEMENTS_MISSING.code,
         message: DIAGNOSTIC_MESSAGES.REPLACEMENTS_MISSING.message(missing),

package/src/features/check/diagnostics/rules/replacement/not-allowed.ts

@@ -27,7 +27,7 @@ export function replacementsNotAllowed(
     return [
       {
         severity: "warn",
-        method,
+        origin: method,
         messageKey: keyPath,
         code: DIAGNOSTIC_MESSAGES.REPLACEMENTS_NOT_ALLOWED.code,
         message: DIAGNOSTIC_MESSAGES.REPLACEMENTS_NOT_ALLOWED.message(),

package/src/features/check/diagnostics/rules/replacement/unused.ts

@@ -32,7 +32,7 @@ export function replacementsUnused(
     return [
       {
         severity: "warn",
-        method,
+        origin: method,
         messageKey: keyPath,
         code: DIAGNOSTIC_MESSAGES.REPLACEMENTS_UNUSED.code,
         message: DIAGNOSTIC_MESSAGES.REPLACEMENTS_UNUSED.message(extra),

package/src/features/check/diagnostics/rules/rich/missing.ts

@@ -32,7 +32,7 @@ export function richMissing(
     return [
       {
         severity: "warn",
-        method,
+        origin: method,
         messageKey: keyPath,
         code: DIAGNOSTIC_MESSAGES.RICH_MISSING.code,
         message: DIAGNOSTIC_MESSAGES.RICH_MISSING.message(missing),

package/src/features/check/diagnostics/rules/rich/not-allowed.ts

@@ -27,7 +27,7 @@ export function richNotAllowed(
     return [
       {
         severity: "warn",
-        method,
+        origin: method,
         messageKey: keyPath,
         code: DIAGNOSTIC_MESSAGES.RICH_NOT_ALLOWED.code,
         message: DIAGNOSTIC_MESSAGES.RICH_NOT_ALLOWED.message(),

package/src/features/check/diagnostics/rules/rich/unused.ts

@@ -32,7 +32,7 @@ export function richUnused(
     return [
       {
         severity: "warn",
-        method,
+        origin: method,
         messageKey: keyPath,
         code: DIAGNOSTIC_MESSAGES.RICH_UNUSED.code,
         message: DIAGNOSTIC_MESSAGES.RICH_UNUSED.message(extra),

package/src/features/check/diagnostics/types.ts

@@ -1,9 +1,6 @@
-import type { TranslatorFactory, TranslatorMethod } from "../../../core";
-
 export interface Diagnostic {
   severity: "error" | "warn";
-  factory?: TranslatorFactory;
-  method?: TranslatorMethod;
+  origin: string;
   messageKey: string;
   code: string;
   message: string;
@@ -14,8 +11,7 @@ export interface Diagnostic {
 
 export interface DiagnosticGroup {
   severity: "error" | "warn";
-  factory?: TranslatorFactory;
-  method?: TranslatorMethod;
+  origin: string;
   messageKey: string;
   problems: string[]; // list of bullet messages
   file: string;

package/src/features/check/print-summary.ts

@@ -13,9 +13,9 @@ export function printSummary(configId: string, grouped: DiagnosticGroup[]) {
 
   // Problems
   for (const group of grouped) {
-    const { factory, method, messageKey, problems, file, lines } = group;
+    const { origin, messageKey, problems, file, lines } = group;
 
-    const header = `${messageKey} (${method ?? factory})`;
+    const header = `${messageKey} (${origin})`;
 
     print(header, 1);
     printList(