@npm-questionpro/wick-ui-i18n 0.9.0 → 0.14.0

package/README.md

@@ -1,78 +1,104 @@
-# Wick UI Auto I18n
+# wick-ui-i18n
 
-**Build-time extractor that wraps static strings in `<WuTranslate>` and generates a JSON dictionary.**
+Vite plugin — wraps JSX text in Wu components with `<WuTranslate>`, rewrites
+translatable props to `{wt("...")}`, and emits `wick-ui-i18n.json`.
 
 ---
 
-### Quick Start
-
-```javascript
-import wickuiI18nPlugin from "@npm-questionpro/wick-ui-i18n";
-export default {
-  plugins: [wickuiI18nPlugin({ debug: true })],
-};
-```
-
----
-
-### 🛠 Attributes
-
-- **`data-i18n-wrapper`**: Forces extraction on non-Wu components (e.g., `<div data-i18n-wrapper>Text</div>`).
-- **`data-i18n-key="custom.key"`**: Overrides the default "text-as-key" behavior.
-- **`data-i18n-skip`**: Prevents the plugin from touching the element or its children.
-
----
-
-### 📖 Rules & Logic
-
-- **Auto-Detection**: Targets all `Wu*` prefixed components by default.
-- **Supported**: Static `JSXText`, `{"Strings"}`, and non-dynamic `{`Template Literals`}`.
-- **Ignored**: Any expression containing variables (e.g., `{`Hello ${name}`}`).
-- **Output**: Generates `dist/wick_extracted_strings.json` during bundle phase.
+## JSX text
+
+| Input | Output |
+|---|---|
+| `<WuButton>Hello</WuButton>` | ✅ `<WuTranslate __i18nKey="Hello" />` |
+| `<WuIcon>star</WuIcon>` | ❌ |
+| `<div>Hello</div>` | ❌ |
+| `<WuButton data-skip>Hello</WuButton>` | ❌ |
+| `<span data-i18n-wrapper>Hello</span>` | ✅ `<WuTranslate __i18nKey="Hello" />` |
+| `<WuButton data-i18n-key="k">Hello</WuButton>` | ✅ `<WuTranslate __i18nKey="k" />` |
+| `<WuButton>&amp;</WuButton>` | ❌ |
+| `<WuButton>Hello &amp; World</WuButton>` | ✅ `<WuTranslate __i18nKey="Hello" /> &amp; <WuTranslate __i18nKey="World" />` |
+
+## JSX string expressions
+
+| Input | Output |
+|---|---|
+| `<WuButton>{"Hello"}</WuButton>` | ✅ `<WuTranslate __i18nKey="Hello" />` |
+| `` <WuButton>{`Hello`}</WuButton> `` | ✅ `<WuTranslate __i18nKey="Hello" />` |
+| `<WuButton>{variable}</WuButton>` | ❌ |
+
+## JSX ternaries
+
+| Input | Output |
+|---|---|
+| `<WuButton>{flag ? "Yes" : "No"}</WuButton>` | ✅ `{flag ? <WuTranslate __i18nKey="Yes" /> : <WuTranslate __i18nKey="No" />}` |
+| `<WuButton>{flag ? "Yes" : variable}</WuButton>` | ✅ `{flag ? <WuTranslate __i18nKey="Yes" /> : variable}` |
+| `<WuButton>{flag ? variable : variable}</WuButton>` | ❌ |
+| `<WuButton>{a ? "A" : b ? "B" : "C"}</WuButton>` | ✅ `{a ? <WuTranslate __i18nKey="A" /> : b ? <WuTranslate __i18nKey="B" /> : <WuTranslate __i18nKey="C" />}` |
+
+## JSX template literals with expressions
+
+| Input | Output |
+|---|---|
+| `` <WuButton>{`Hello ${name}`}</WuButton> `` | ✅ `<><WuTranslate __i18nKey="Hello" /> {name}</>` |
+| `` <WuButton>{`${name} world`}</WuButton> `` | ✅ `<>{name} <WuTranslate __i18nKey="world" /></>` |
+| `` <WuButton>{`Hello ${a} and ${b}`}</WuButton> `` | ✅ `<><WuTranslate __i18nKey="Hello" /> {a} <WuTranslate __i18nKey="and" /> {b}</>` |
+| `` <WuButton>{`${a}${b}`}</WuButton> `` | ❌ |
+
+## JSX mixed children
+
+| Input | Output |
+|---|---|
+| `<WuButton>Hello {name}</WuButton>` | ✅ `<WuTranslate __i18nKey="Hello" /> {name}` |
+| `<WuButton>{a} and {b}</WuButton>` | ✅ `{a} <WuTranslate __i18nKey="and" /> {b}` |
+| `<WuButton>{a}   {b}</WuButton>` | ❌ |
+
+## JSX props
+
+Defaults: `Label`, `placeholder`, `title`, `aria-label`, `aria-placeholder`.
+
+| Input | Output |
+|---|---|
+| `<WuField Label="First name" />` | ✅ `Label={wt("First name")}` |
+| `<WuInput placeholder="Enter name" />` | ✅ `placeholder={wt("Enter name")}` |
+| `<WuDialog title="Confirm?" />` | ✅ `title={wt("Confirm?")}` |
+| `<WuField Label={variable} />` | ❌ |
+| `<WuField Label="" />` | ❌ |
+| `<WuIcon Label="x" />` | ❌ |
+| `<input placeholder="x" />` | ❌ |
+| `<WuField data-skip Label="x" />` | ❌ |
+
+## `wt()` calls
+
+Plugin records static args into `wick-ui-i18n.json`. No code rewrite unless template literal with expressions.
+
+| Input | Dictionary | Code output |
+|---|---|---|
+| `wt("Hello")` | ✅ `"Hello"` | `wt("Hello")` |
+| `` wt(`Hello`) `` | ✅ `"Hello"` | `` wt(`Hello`) `` |
+| `` wt(`Hello ${name}`) `` | ✅ `"Hello"` | `` `${wt("Hello")} ${name}` `` |
+| `` wt(`Hello ${a} and ${b}`) `` | ✅ `"Hello"`, `"and"` | `` `${wt("Hello")} ${a} ${wt("and")} ${b}` `` |
+| `wt(variable)` | ❌ | — |
+| `` wt(`${a}${b}`) `` | ❌ | — |
+
+## Data files (`extractFromKeys` option)
+
+No code rewrite — keys only recorded in `wick-ui-i18n.json`.
+
+| Input | Dictionary |
+|---|---|
+| `{ label: 'Analytics' }` + `extractFromKeys: ['label']` | ✅ `"Analytics"` |
+| `{ label: variable }` | ❌ |
+| `{ label: '' }` | ❌ |
 
 ---
 
-### 🔄 Logic Map (Pseudo-code)
-
-```text
-FOR each File in the Project:
-    IF File matches IncludeFilter AND contains "Wu":
-        PARSE File into an AST (Abstract Syntax Tree)
-        INITIALIZE MagicString (for non-destructive editing)
-
-        TRAVERSE the AST:
-
-            // 1. IMPORT CHECK
-            IF Node is an Import from '@wick-ui-lib':
-                MARK 'WuTranslate' as already imported if found
-
-            // 2. STRING DISCOVERY
-            IF Node is JSXText OR (JSXExpressionContainer WITH StaticString):
-                SET CandidateText = Node.Value
-
-                // 3. HIERARCHY EVALUATION (The "shouldTranslate" logic)
-                WALK UP from Node to Parents:
-                    IF Parent has [data-skip] attribute:
-                        ABORT (Don't translate this node)
-
-                    IF Parent has [data-i18n-wrapper] attribute:
-                        MARK as "Valid Target" and STOP walking up
-
-                    IF Parent.Name starts with "Wu" OR is in CustomList:
-                        IF Parent.Name is NOT in IgnoreList:
-                            MARK as "Valid Target" and STOP walking up
-
-                // 4. TRANSFORMATION
-                IF "Valid Target" was found:
-                    GET ExplicitKey from [data-i18n-key] OR USE CandidateText
-                    STORE { Key, CandidateText } in GlobalDictionary
-                    OVERWRITE original code with:
-                        `<WuTranslate __i18nKey="Key">OriginalText</WuTranslate>`
-                    SET NeedsImport = True
-
-        // 5. FINAL ASSEMBLY
-        IF NeedsImport AND NOT 'WuTranslate' Imported:
-            PREPEND import statement to top of file
+## Options
 
-        RETURN Modified Code + Source Maps
-```
+| Option | Default | Description |
+|---|---|---|
+| `components` | `[]` | Extra components treated like Wu* |
+| `ignoreComponents` | `[]` | Extra components never translated |
+| `translatableProps` | `['Label','placeholder','title','aria-label','aria-placeholder']` | Props rewritten to `wt()` |
+| `extractFromKeys` | `[]` | Object keys extracted into dictionary |
+| `excludeFiles` | — | Files skipped entirely |
+| `debug` | `false` | Log transforms to console |

package/index.d.ts

@@ -1,28 +1,37 @@
-export interface AutoTranslateOptions {
+import type {Plugin} from 'vite'
+
+export interface WickI18nOptions {
+  /** Extra component names to translate (in addition to Wu* components). */
+  components?: string[]
+
+  /** Component names to exclude from translation. */
+  ignoreComponents?: string[]
+
   /**
-   * List of components to extract text from.
-   * If empty, matches all Wu* components automatically.
+   * JSX prop names rewritten to `{wt("...")}` on Wu* components.
+   * @default ['Label', 'placeholder', 'title', 'aria-label', 'aria-placeholder']
    */
-  components?: string[];
+  translatableProps?: string[]
 
   /**
-   * List of components to ignore text from.
+   * Object property names whose string values are extracted into
+   * `wick-ui-i18n.json` without rewriting code. Use for data files
+   * (nav items, option lists, etc.) paired with `wt(item.label)` at render time.
    */
-  ignoreComponents?: string[];
+  extractFromKeys?: string[]
 
-  // /**
-  //  * Files to include in the transformation.
-  //  * Can be string, RegExp, or array of string/RegExp.
-  //  */
-  // include?: any;
+  /** Files to skip entirely. Passed to Vite's `createFilter` as `exclude`. */
+  excludeFiles?: string | RegExp | Array<string | RegExp>
 
-  /**
-   * Enable debug logging for extraction process.
-   */
-  debug?: boolean;
+  /** Log every transform to the console. */
+  debug?: boolean
 }
 
 /**
- * Vite plugin that extracts text from Wick UI components and wraps them in WuTranslate.
+ * Vite plugin that automatically translates Wick UI components.
+ *
+ * - JSX text content inside Wu* → `<WuTranslate __i18nKey="..." />`
+ * - Translatable props (placeholder, title, Label, …) → `{wt("...")}`
+ * - Emits `wick-ui-i18n.json` with all extracted keys
  */
-export default function autoTranslate(options?: AutoTranslateOptions): any;
+export default function wickuiI18nPlugin(options?: WickI18nOptions): Plugin

package/index.js

@@ -27,6 +27,8 @@ import { printReport } from "./src/debug.js";
  * @typedef {object} WickI18nOptions
  * @property {string[]}  [components]        - Extra component names that trigger translation.
  * @property {string[]}  [ignoreComponents]  - Component names to exclude from translation.
+ * @property {string[]}  [translatableProps] - JSX prop names rewritten to `{wt("...")}`. Defaults to `['Label','placeholder','title','aria-label','aria-placeholder']`.
+ * @property {string[]}  [extractFromKeys]   - Object property names whose string values are extracted as translation keys (e.g. ['label']).
  * @property {string|string[]|RegExp} [excludeFiles] - Files to skip (passed as `exclude` to Vite's createFilter).
  * @property {boolean}   [debug]             - Log transform activity to the console.
  */
@@ -41,15 +43,29 @@ export default function wickuiI18nPlugin(options = {}) {
   const processor = new TranslationProcessor({
     components: options.components || [],
     ignoreComponents: options.ignoreComponents,
+    translatableProps: options.translatableProps,
+    extractFromKeys: options.extractFromKeys,
     debug: options.debug,
   });
 
-  const filter = createFilter([/\.(jsx|tsx)$/], options.excludeFiles);
+  const filter = createFilter([/\.(jsx|tsx|ts)$/], options.excludeFiles);
+
+  let base = "/";
 
   return {
     name: "wick-ui-i18n",
     enforce: "pre",
 
+    /**
+     * Capture the resolved base so the dev-server middleware path matches
+     * what `import.meta.env.BASE_URL` resolves to in the consumer app.
+     *
+     * @param {import('vite').ResolvedConfig} resolvedConfig
+     */
+    configResolved(resolvedConfig) {
+      base = resolvedConfig.base;
+    },
+
     /**
      * Clear state on every build so stale keys don't accumulate across
      * watch-mode rebuilds.
@@ -67,7 +83,14 @@ export default function wickuiI18nPlugin(options = {}) {
      * @param {string} id
      */
     transform(code, id) {
-      if (!filter(id) || !code.includes("Wu")) return null;
+      const hasAnyTarget =
+        code.includes("Wu") ||
+        /\bwt\(/.test(code) ||
+        (processor.components.size > 0 &&
+          [...processor.components].some(c => code.includes(c))) ||
+        (processor.extractFromKeys.size > 0 &&
+          [...processor.extractFromKeys].some(k => code.includes(k)));
+      if (!filter(id) || !hasAnyTarget) return null;
       return transformFile(code, id, processor);
     },
 
@@ -77,7 +100,7 @@ export default function wickuiI18nPlugin(options = {}) {
      * @param {import('vite').ViteDevServer} server
      */
     configureServer(server) {
-      server.middlewares.use("/wick-ui-i18n.json", (_req, res) => {
+      server.middlewares.use(`${base}wick-ui-i18n.json`, (_req, res) => {
         res.setHeader("Content-Type", "application/json");
         res.end(
           JSON.stringify(Object.fromEntries(processor.dictionary), null, 2),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npm-questionpro/wick-ui-i18n",
-  "version": "0.9.0",
+  "version": "0.14.0",
   "license": "ISC",
   "description": "Auto-translation AST wrapper for Wick UI",
   "type": "module",

package/src/processor.js

@@ -3,6 +3,9 @@
  * decides which JSX nodes should be wrapped with WuTranslate.
  */
 
+/** Prop names translated by default on Wu* components. Pass `translatableProps` to override. */
+const DEFAULT_TRANSLATABLE_PROPS = ['Label', 'placeholder', 'title', 'aria-label', 'aria-placeholder']
+
 /** Components always excluded from translation regardless of user config. */
 const DEFAULT_IGNORE = [
   "WuIcon",
@@ -21,16 +24,24 @@ const DEFAULT_IGNORE = [
 
 export class TranslationProcessor {
   /**
-   * @param {object} options
-   * @param {string[]} options.components       - Component names that trigger translation.
-   * @param {string[]} [options.ignoreComponents] - Extra components to exclude.
-   * @param {boolean}  [options.debug]           - Enable verbose logging.
+   * @param {object}   options
+   * @param {string[]} options.components          - Component names that trigger translation.
+   * @param {string[]} [options.ignoreComponents]  - Extra components to exclude.
+   * @param {string[]} [options.translatableProps] - JSX prop names to rewrite to wt(). Overrides defaults.
+   * @param {string[]} [options.extractFromKeys]   - Object property names whose string values are recorded.
+   * @param {boolean}  [options.debug]             - Enable verbose logging.
    */
   constructor(options) {
     this.components = new Set(options.components);
     this.ignoreComponents = new Set(
       DEFAULT_IGNORE.concat(options.ignoreComponents || []),
     );
+    /** @type {Set<string>} JSX prop names that should be translated. */
+    this.translatableProps = new Set(
+      options.translatableProps ?? DEFAULT_TRANSLATABLE_PROPS,
+    );
+    /** @type {Set<string>} Object property key names whose string values are extracted (e.g. 'label'). */
+    this.extractFromKeys = new Set(options.extractFromKeys || []);
     /** @type {Map<string, string>} key → original text */
     this.dictionary = new Map();
     /** @type {import('./debug.js').DebugEntry[]} */
@@ -120,6 +131,27 @@ export class TranslationProcessor {
     return targetFound && !isIgnored;
   }
 
+  /**
+   * Return `true` when `propName` is in the translatable-props set and the
+   * immediate parent JSX element is a Wu* component or in `components`, and
+   * is not in `ignoreComponents`. Matched props are rewritten to `{wt("...")}`. *
+   * @param {string} propName
+   * @param {import('@babel/traverse').NodePath} path - JSXAttribute path.
+   * @returns {boolean}
+   */
+  shouldTranslateProp(propName, path) {
+    if (!this.translatableProps.has(propName)) return false;
+    // path.parent is the JSXOpeningElement node
+    const openingEl = path.parent;
+    const name = openingEl.name?.name || openingEl.name?.property?.name;
+    if (!name) return false;
+    if (this.ignoreComponents.has(name)) return false;
+    // Respect data-skip / data-i18n-skip on the same element
+    const attrs = openingEl.attributes || [];
+    if (attrs.some(a => ['data-skip', 'data-i18n-skip'].includes(a.name?.name))) return false;
+    return name.startsWith('Wu') || this.components.has(name);
+  }
+
   /**
    * Return the explicit i18n key from the nearest ancestor JSX element's
    * `data-i18n-key` attribute, or `null` if absent.

package/src/transform.js

@@ -1,18 +1,34 @@
 /**
- * @fileoverview AST transform — parses a JSX/TSX file, rewrites translatable
- * text nodes to `<WuTranslate>`, and prepends the import if needed.
+ * @fileoverview AST transform — parses a JSX/TSX/TS file and:
+ *   - Rewrites JSX text content inside Wu* components to `<WuTranslate>`
+ *   - Rewrites translatable props (placeholder, title, …) to `{wt("…")}`
+ *   - Prepends the necessary imports when added.
  */
 
 import MagicString from "magic-string";
 import { parse } from "@babel/parser";
 import _traverse from "@babel/traverse";
 import { getComponentTree } from "./debug.js";
+import { transformTemplateLiteralExpression } from "./transformTemplateLiteral.js";
+import { transformJSXTextWithEntities } from "./transformJSXTextWithEntities.js";
+import {
+  recordWtCall,
+  transformWtTemplateLiteral,
+} from "./transformWtCalls.js";
 
 const traverse = _traverse.default || _traverse;
 
 /** Babel parser plugins applied to every file. */
 const BABEL_PLUGINS = ["jsx", "typescript"];
 
+/**
+ * Matches any HTML entity: named (&amp;), decimal (&#169;), or hex (&#x00A9;).
+ * Used to skip text segments that contain entities — they must be left as-is.
+ * Note: for JSXText this must be tested against the RAW source, not the Babel
+ * decoded .value (Babel turns &amp; → "&", &nbsp; → "\u00a0", etc.).
+ */
+const HTML_ENTITY_RE = /&(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);/;
+
 /** @param {import('@babel/types').Node} node @returns {string|null} */
 function getStaticString(node) {
   if (node.type === "StringLiteral") return node.value;
@@ -21,6 +37,34 @@ function getStaticString(node) {
   return null;
 }
 
+/**
+ * Recursively handle a ConditionalExpression, wrapping every static string
+ * branch (at any nesting depth) with WuTranslate.
+ *
+ * @param {import('@babel/types').ConditionalExpression} expr
+ * @param {import('@babel/traverse').NodePath} path
+ * @param {MagicString} ms
+ * @param {import('./processor.js').TranslationProcessor} processor
+ * @param {string} id
+ * @returns {boolean} true when at least one branch was captured
+ */
+function handleConditional(expr, path, ms, processor, id) {
+  let changed = false;
+
+  for (const branch of [expr.consequent, expr.alternate]) {
+    const text = getStaticString(branch);
+    if (text !== null) {
+      changed =
+        handleCapture(path, text, branch.start, branch.end, ms, processor, id, true) ||
+        changed;
+    } else if (branch.type === "ConditionalExpression") {
+      changed = handleConditional(branch, path, ms, processor, id) || changed;
+    }
+  }
+
+  return changed;
+}
+
 /**
  * Replace a translatable text node with a `<WuTranslate>` element and record
  * the key in the processor's dictionary.
@@ -34,18 +78,29 @@ function getStaticString(node) {
  * @param {string}       id         - File path (for collision warnings).
  * @returns {boolean} `true` when replacement was made.
  */
-function handleCapture(path, text, start, end, ms, processor, id, skipExplicitKey = false) {
-  const cleanText = text.trim().replace(/\n/g, " ").replace(/\s{2,}/g, " ");
+function handleCapture(
+  path,
+  text,
+  start,
+  end,
+  ms,
+  processor,
+  id,
+  skipExplicitKey = false,
+) {
+  const cleanText = text
+    .trim()
+    .replace(/\n/g, " ")
+    .replace(/\s{2,}/g, " ");
   if (!cleanText || !processor.shouldTranslate(path)) return false;
+  // For StringLiteral / TemplateLiteral quasis / ternary branches: entities are
+  // not decoded by the JS parser, so cleanText still contains "&amp;" etc.
+  if (HTML_ENTITY_RE.test(cleanText)) return false;
 
   const key = (!skipExplicitKey && processor.getExplicitKey(path)) || cleanText;
   processor.record(key, cleanText, id, getComponentTree(path));
 
-  ms.overwrite(
-    start,
-    end,
-    `<WuTranslate __i18nKey=${JSON.stringify(key)}></WuTranslate>`,
-  );
+  ms.overwrite(start, end, `<WuTranslate __i18nKey=${JSON.stringify(key)}></WuTranslate>`);
   return true;
 }
 
@@ -68,24 +123,92 @@ export function transformFile(code, id, processor) {
   const ms = new MagicString(code);
   let needsImport = false;
   let hasImport = false;
+  let hasWtTransform = false;
+  let needsWtImport = false;
+  let hasWtImport = false;
 
   traverse(ast, {
-    /**
-     * Track whether `WuTranslate` is already imported from wick-ui-lib so we
-     * don't duplicate the import statement.
+    /** wt("static string") call — record the key in the dictionary.
+     * No code transformation; wt() handles runtime lookup.
      */
+    CallExpression(path) {
+      if (recordWtCall(path, processor, id)) return;
+      if (transformWtTemplateLiteral(path, code, ms, processor, id)) {
+        hasWtTransform = true;
+      }
+    },
+
+    /** Track whether WuTranslate / wt are already imported so we don't duplicate them. */
     ImportDeclaration(path) {
       if (path.node.source.value.includes("wick-ui-lib")) {
-        hasImport = path.node.specifiers.some(
-          (s) => s.imported?.name === "WuTranslate",
-        );
+        for (const s of path.node.specifiers) {
+          if (s.imported?.name === "WuTranslate") hasImport = true;
+          if (s.imported?.name === "wt") hasWtImport = true;
+        }
       }
     },
 
+    /**
+     * Data-file key extraction: records string values of configured object
+     * property names (e.g. `label: 'Analytics'`) without rewriting code.
+     * Enabled via `extractFromKeys` option.
+     */
+    ObjectProperty(path) {
+      if (!processor.extractFromKeys.size) return;
+      const keyNode = path.node.key;
+      const keyName = keyNode.name ?? keyNode.value;
+      if (!keyName || !processor.extractFromKeys.has(keyName)) return;
+      const value = path.node.value;
+      if (value.type !== "StringLiteral") return;
+      const text = value.value
+        .trim()
+        .replace(/\n/g, " ")
+        .replace(/\s{2,}/g, " ");
+      if (!text) return;
+      if (HTML_ENTITY_RE.test(text)) return;
+      processor.record(text, text, id, "(data)");
+    },
+
+    /**
+     * Translatable props (Label, placeholder, title, aria-label, ...)
+     * rewritten to `{wt("foo")}` on Wu* components.
+     */
+    JSXAttribute(path) {
+      const propName = path.node.name.name;
+      if (typeof propName !== "string") return;
+      const value = path.node.value;
+      if (!value || value.type !== "StringLiteral") return;
+
+      const rawValue = code.slice(value.start, value.end);
+      if (HTML_ENTITY_RE.test(rawValue)) return;
+
+      const text = value.value
+        .trim()
+        .replace(/\n/g, " ")
+        .replace(/\s{2,}/g, " ");
+      if (!text) return;
+
+      if (!processor.shouldTranslateProp(propName, path)) return;
+
+      processor.record(text, text, id, getComponentTree(path));
+      ms.overwrite(value.start, value.end, `{wt(${JSON.stringify(text)})}`);
+      needsWtImport = true;
+    },
+
     /** Plain JSX text: `<Foo>Hello world</Foo>` */
     JSXText(path) {
       const text = path.node.value;
       const trimmed = text.trim();
+      // Babel decodes entities in JSXText.value (&amp; → "&", &#169; → "©").
+      // Check the raw source slice — if entities found, split around them so
+      // translatable text segments are still wrapped while entities stay put.
+      const rawSource = code.slice(path.node.start, path.node.end);
+      if (HTML_ENTITY_RE.test(rawSource)) {
+        if (transformJSXTextWithEntities(path, rawSource, ms, processor, id)) {
+          needsImport = true;
+        }
+        return;
+      }
       const start = path.node.start + text.indexOf(trimmed);
       if (
         handleCapture(
@@ -117,37 +240,18 @@ export function transformFile(code, id, processor) {
 
       if (expr.type === "StringLiteral") {
         text = expr.value;
+      } else if (
+        expr.type === "TemplateLiteral" &&
+        expr.expressions.length > 0
+      ) {
+        if (transformTemplateLiteralExpression(path, code, ms, processor, id)) {
+          needsImport = true;
+        }
+        return;
       } else if (expr.type === "TemplateLiteral" && !expr.expressions.length) {
         text = expr.quasis[0].value.cooked;
       } else if (expr.type === "ConditionalExpression") {
-        const consText = getStaticString(expr.consequent);
-        const altText = getStaticString(expr.alternate);
-        let changed = false;
-        if (consText !== null)
-          changed =
-            handleCapture(
-              path,
-              consText,
-              expr.consequent.start,
-              expr.consequent.end,
-              ms,
-              processor,
-              id,
-              true,
-            ) || changed;
-        if (altText !== null)
-          changed =
-            handleCapture(
-              path,
-              altText,
-              expr.alternate.start,
-              expr.alternate.end,
-              ms,
-              processor,
-              id,
-              true,
-            ) || changed;
-        if (changed) needsImport = true;
+        if (handleConditional(expr, path, ms, processor, id)) needsImport = true;
         return;
       }
 
@@ -168,9 +272,13 @@ export function transformFile(code, id, processor) {
     },
   });
 
-  if (!needsImport) return null;
+  if (!needsImport && !hasWtTransform && !needsWtImport) return null;
+
+  if (needsWtImport && !hasWtImport) {
+    ms.prepend(`import { wt } from '@npm-questionpro/wick-ui-lib';\n`);
+  }
 
-  if (!hasImport) {
+  if (needsImport && !hasImport) {
     ms.prepend(`import { WuTranslate } from '@npm-questionpro/wick-ui-lib';\n`);
   }