@npm-questionpro/wick-ui-i18n 0.8.0 → 0.10.0

package/wickuii18n.test.js

@@ -1,13 +1,29 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import wickuiI18nPlugin from "./index.js";
 
-// Helper to simulate Vite running the transform hook
 function transform(code, options = {}) {
   const plugin = wickuiI18nPlugin(options);
   const result = plugin.transform(code, "TestFile.jsx");
   return result ? result.code : code;
 }
 
+/**
+ * Run the full plugin lifecycle on `code` and return the emitted dictionary.
+ * Needed for wt() tests since those record keys without transforming code.
+ */
+function getDictionary(code, options = {}) {
+  const plugin = wickuiI18nPlugin(options);
+  plugin.buildStart();
+  plugin.transform(code, "TestFile.jsx");
+  let dict = {};
+  plugin.generateBundle.call({
+    emitFile: ({ source }) => {
+      dict = JSON.parse(source);
+    },
+  });
+  return dict;
+}
+
 describe("Wick UI i18n Vite Plugin", () => {
   it("1. Translates basic Wu* components and injects import", () => {
     const code = `<WuButton>Submit</WuButton>`;
@@ -50,6 +66,23 @@ describe("Wick UI i18n Vite Plugin", () => {
     );
   });
 
+  it("6b. data-i18n-key propagates through nested elements", () => {
+    const code = `<WuButton data-i18n-key="btn_login"><span>Log In</span></WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(
+      `<WuTranslate __i18nKey="btn_login"></WuTranslate>`,
+    );
+    expect(result).not.toContain(`__i18nKey="Log In"`);
+  });
+
+  it("6c. data-i18n-key on ternary parent is ignored — each branch uses its own text as key", () => {
+    const code = `<WuButton data-i18n-key="btn">{flag ? "Yes" : "No"}</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(`<WuTranslate __i18nKey="Yes"></WuTranslate>`);
+    expect(result).toContain(`<WuTranslate __i18nKey="No"></WuTranslate>`);
+    expect(result).not.toContain(`__i18nKey="btn"`);
+  });
+
   it("7. Translates JSX Expression Containers (Strings in braces)", () => {
     const code = `<WuButton>{"Hello World"}</WuButton>`;
     const result = transform(code);
@@ -58,14 +91,13 @@ describe("Wick UI i18n Vite Plugin", () => {
     );
   });
 
-  // it("8. Supports custom components via options", () => {
-  //   const code = `<CustomCard>Welcome</CustomCard>`;
-  //   const result = transform(code, { components: ["CustomCard"] });
-  //   expect(result).toContain(
-  //     `<WuTranslate __i18nKey="Welcome">Welcome</WuTranslate>`,
-  //   );
-  // });
-  //
+  it("8. Does not translate JSX attribute string values", () => {
+    const code = `<WuButton variant={'secondary'}>Submit</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain(`__i18nKey="secondary"`);
+    expect(result).toContain(`<WuTranslate __i18nKey="Submit"></WuTranslate>`);
+  });
+
   it("9. Supports data-i18n-wrapper on non-target tags", () => {
     const code = `<span data-i18n-wrapper>Wrapped Text</span>`;
     const triggerCode = `import { WuPlaceholder } from 'lib';\n` + code;
@@ -74,4 +106,490 @@ describe("Wick UI i18n Vite Plugin", () => {
       `<WuTranslate __i18nKey="Wrapped Text"></WuTranslate>`,
     );
   });
+
+  it("10. Skips files matching excludeFiles", () => {
+    const code = `<WuButton>Submit</WuButton>`;
+    const plugin = wickuiI18nPlugin({ excludeFiles: ["**/ignored/**"] });
+    const hit = plugin.transform(code, "src/components/Form.jsx");
+    const miss = plugin.transform(code, "src/ignored/Form.jsx");
+    expect(hit?.code).toContain("WuTranslate");
+    expect(miss).toBeNull();
+  });
+
+  it("11. Strips newline from JSX text node", () => {
+    const code = `<WuButton>Hello\nWorld</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(
+      `<WuTranslate __i18nKey="Hello World"></WuTranslate>`,
+    );
+  });
+
+  it("11b. Collapses multiple newlines/spaces into a single space", () => {
+    const code = `<WuButton>Hello\n\n  World</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(
+      `<WuTranslate __i18nKey="Hello World"></WuTranslate>`,
+    );
+  });
+
+  it("12. Translates both static branches of a ternary", () => {
+    const code = `<WuButton>{isActive ? "Deactivate" : "Activate"}</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(
+      `<WuTranslate __i18nKey="Deactivate"></WuTranslate>`,
+    );
+    expect(result).toContain(
+      `<WuTranslate __i18nKey="Activate"></WuTranslate>`,
+    );
+    expect(result).toContain(`isActive ?`);
+    expect(result).toContain(`import { WuTranslate }`);
+  });
+
+  it("12b. Translates only the static branch when one side is dynamic", () => {
+    const code = `<WuButton>{isActive ? "Deactivate" : dynamicLabel}</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(
+      `<WuTranslate __i18nKey="Deactivate"></WuTranslate>`,
+    );
+    expect(result).toContain(`dynamicLabel`);
+    expect(result).not.toContain(`__i18nKey="dynamicLabel"`);
+  });
+
+  it("12c. Skips ternary when both branches are dynamic", () => {
+    const code = `<WuButton>{isActive ? labelA : labelB}</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain(`WuTranslate`);
+    expect(result).toContain(`labelA`);
+    expect(result).toContain(`labelB`);
+  });
+
+  it("12d. Translates ternary with template literal branches", () => {
+    const code = "<WuButton>{flag ? `Yes` : `No`}</WuButton>";
+    const result = transform(code);
+    expect(result).toContain(`<WuTranslate __i18nKey="Yes"></WuTranslate>`);
+    expect(result).toContain(`<WuTranslate __i18nKey="No"></WuTranslate>`);
+  });
+
+  it("12e. Skips ternary inside ignored component", () => {
+    const code = `<WuIcon>{flag ? "A" : "B"}</WuIcon>`;
+    const result = transform(code);
+    expect(result).not.toContain(`WuTranslate`);
+  });
+
+  it("12f. Respects data-skip on parent of ternary", () => {
+    const code = `<WuButton data-skip>{flag ? "A" : "B"}</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain(`WuTranslate`);
+  });
+
+  it("12g. Nested ternary: translates first branch, skips inner ternary", () => {
+    // {a ? "A" : b ? "B" : "C"} — alternate is ConditionalExpression, not a static string
+    const code = `<WuButton>{a ? "A" : b ? "B" : "C"}</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(`<WuTranslate __i18nKey="A"></WuTranslate>`);
+    // inner ternary branches are not translated (known v1 limitation)
+    expect(result).toContain(`b ? "B" : "C"`);
+  });
+
+  it("12h. Ternary outside any Wu/wrapper component is not translated", () => {
+    const code = `<div>{flag ? "A" : "B"}</div>`;
+    const result = transform(code);
+    expect(result).not.toContain(`WuTranslate`);
+  });
+
+  it("13. Translates dynamic string literals", () => {
+    const code = `<WuButton>Submit {name}</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(`import { WuTranslate }`);
+    expect(result).toContain(`<WuTranslate __i18nKey="Submit"></WuTranslate>`);
+  });
+});
+
+// ─── HTML entities ─────────────────────────────────────────────────────────
+//
+// Any text segment containing an HTML entity must be left completely untouched.
+// Entities are presentational / structural characters (&nbsp;, &amp;, &copy;…)
+// that are not translatable and would confuse translation APIs.
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("HTML entities", () => {
+  it("E1. standalone named entity is not wrapped", () => {
+    const code = `<WuButton>&amp;</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain("WuTranslate");
+    expect(result).toContain("&amp;");
+  });
+
+  it("E2. text mixed with entity — non-entity parts wrapped, entity preserved", () => {
+    const code = `<WuButton>Hello &amp; World</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(`<WuTranslate __i18nKey="Hello"></WuTranslate>`);
+    expect(result).toContain(`<WuTranslate __i18nKey="World"></WuTranslate>`);
+    expect(result).toContain("&amp;");
+    // must not treat the whole string (decoded or raw) as one key
+    expect(result).not.toContain(`__i18nKey="Hello & World"`);
+    expect(result).not.toContain(`__i18nKey="Hello &amp; World"`);
+  });
+
+  it("E3. non-breaking space entity is not wrapped", () => {
+    const code = `<WuButton>&nbsp;</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain("WuTranslate");
+  });
+
+  it("E4. numeric decimal entity is not wrapped", () => {
+    // &#169; = ©
+    const code = `<WuButton>&#169;</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain("WuTranslate");
+  });
+
+  it("E5. numeric hex entity is not wrapped", () => {
+    // &#x00A9; = ©
+    const code = `<WuButton>&#x00A9;</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain("WuTranslate");
+  });
+
+  it("E6. entity inside static string expression is not wrapped", () => {
+    const code = `<WuButton>{"Hello &amp; World"}</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain("WuTranslate");
+  });
+
+  it("E7. entity branch in ternary not wrapped, clean branch still wrapped", () => {
+    const code = `<WuButton>{flag ? "Yes &amp;" : "No"}</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain(`__i18nKey="Yes &amp;"`);
+    expect(result).toContain(`<WuTranslate __i18nKey="No"></WuTranslate>`);
+  });
+
+  it("E8. entity JSXText sibling not wrapped, clean siblings still wrapped", () => {
+    // <WuButton>Hello {x}&amp;{y} World</WuButton>
+    // JSXText nodes: "Hello ", "&amp;", " World"
+    // Babel decodes &amp; → "&" in .value, so check both forms are absent
+    const code = `<WuButton>Hello {x}&amp;{y} World</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(`<WuTranslate __i18nKey="Hello"></WuTranslate>`);
+    expect(result).not.toContain(`__i18nKey="&amp;"`);
+    expect(result).not.toContain(`__i18nKey="&"`);
+    expect(result).toContain(`<WuTranslate __i18nKey="World"></WuTranslate>`);
+  });
+
+  it("E9. multiple entities — text between them wrapped, both entities kept", () => {
+    // &lt;Tag&gt;  →  &lt;<WuTranslate key="Tag" />&gt;
+    const code = `<WuButton>&lt;Tag&gt;</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(`<WuTranslate __i18nKey="Tag"></WuTranslate>`);
+    expect(result).toContain("&lt;");
+    expect(result).toContain("&gt;");
+  });
+
+  it("E10. entity at boundaries — text in middle still wrapped", () => {
+    // &nbsp;Hello&nbsp;  →  &nbsp;<WuTranslate key="Hello" />&nbsp;
+    const code = `<WuButton>&nbsp;Hello&nbsp;</WuButton>`;
+    const result = transform(code);
+    expect(result).toContain(`<WuTranslate __i18nKey="Hello"></WuTranslate>`);
+    expect(result).toContain("&nbsp;");
+  });
+
+  it("E11. only entities, no text — nothing wrapped", () => {
+    const code = `<WuButton>&lt;&gt;</WuButton>`;
+    const result = transform(code);
+    expect(result).not.toContain("WuTranslate");
+  });
+
+  // fix 1: whitespace normalisation inside entity-split segments
+  it("E12. internal newlines in entity-split segment are normalised", () => {
+    const code = "<WuButton>Hello\nWorld &amp; Goodbye\nFriend</WuButton>";
+    const result = transform(code);
+    expect(result).toContain(`__i18nKey="Hello World"`);
+    expect(result).toContain(`__i18nKey="Goodbye Friend"`);
+    expect(result).not.toContain("Hello\\nWorld");
+  });
+
+  it("E13. multiple spaces in entity-split segment are collapsed", () => {
+    const code = "<WuButton>Hello  World &amp; Foo</WuButton>";
+    const result = transform(code);
+    expect(result).toContain(`__i18nKey="Hello World"`);
+    expect(result).toContain(`__i18nKey="Foo"`);
+    expect(result).not.toContain(`__i18nKey="Hello  World"`);
+  });
+
+  // fix 2: data-i18n-key bypass
+  it("E14. data-i18n-key with entity — warns and splits using text as keys", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const code = `<WuButton data-i18n-key="btn">Hello &amp; World</WuButton>`;
+    const result = transform(code);
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('data-i18n-key="btn"'),
+    );
+    expect(result).toContain(`__i18nKey="Hello"`);
+    expect(result).toContain(`__i18nKey="World"`);
+    expect(result).not.toContain(`__i18nKey="btn"`);
+    warnSpy.mockRestore();
+  });
+});
+
+describe("Mixed static + dynamic interpolation", () => {
+  describe("A: JSX mixed children", () => {
+    it("A1. text before dynamic  →  wraps leading text, keeps expr", () => {
+      // <WuButton>hello {name}</WuButton>
+      // children: JSXText("hello ") + JSXExpressionContainer(name)
+      const code = `<WuButton>hello {name}</WuButton>`;
+      const result = transform(code);
+      expect(result).toContain(`<WuTranslate __i18nKey="hello"></WuTranslate>`);
+      expect(result).toContain(`{name}`);
+      expect(result).not.toContain(`__i18nKey="name"`);
+    });
+
+    it("A2. dynamic before text  →  keeps expr, wraps trailing text", () => {
+      // <WuButton>{name} how are you</WuButton>
+      const code = `<WuButton>{name} how are you</WuButton>`;
+      const result = transform(code);
+      expect(result).toContain(
+        `<WuTranslate __i18nKey="how are you"></WuTranslate>`,
+      );
+      expect(result).toContain(`{name}`);
+    });
+
+    it("A3. text + dynamic + text  →  wraps both text segments independently", () => {
+      // <WuButton>hello {name} how are you</WuButton>
+      const code = `<WuButton>hello {name} how are you</WuButton>`;
+      const result = transform(code);
+      expect(result).toContain(`<WuTranslate __i18nKey="hello"></WuTranslate>`);
+      expect(result).toContain(
+        `<WuTranslate __i18nKey="how are you"></WuTranslate>`,
+      );
+      expect(result).toContain(`{name}`);
+    });
+
+    it("A4. multiple dynamics with text between  →  wraps middle text", () => {
+      // <WuButton>{a} and {b}</WuButton>
+      const code = `<WuButton>{a} and {b}</WuButton>`;
+      const result = transform(code);
+      expect(result).toContain(`<WuTranslate __i18nKey="and"></WuTranslate>`);
+      expect(result).toContain(`{a}`);
+      expect(result).toContain(`{b}`);
+    });
+
+    it("A5. text + two dynamics + text  →  wraps outer text, keeps both exprs", () => {
+      // <WuButton>hello {a} and {b} end</WuButton>
+      const code = `<WuButton>hello {a} and {b} end</WuButton>`;
+      const result = transform(code);
+      expect(result).toContain(`<WuTranslate __i18nKey="hello"></WuTranslate>`);
+      expect(result).toContain(`<WuTranslate __i18nKey="and"></WuTranslate>`);
+      expect(result).toContain(`<WuTranslate __i18nKey="end"></WuTranslate>`);
+      expect(result).toContain(`{a}`);
+      expect(result).toContain(`{b}`);
+    });
+
+    it("A6. whitespace-only text between two dynamics  →  not wrapped", () => {
+      // <WuButton>{a}   {b}</WuButton>  — JSXText between them is only spaces
+      const code = `<WuButton>{a}   {b}</WuButton>`;
+      const result = transform(code);
+      // whitespace-only JSXText must not produce a key
+      expect(result).not.toContain(`WuTranslate`);
+    });
+  });
+
+  // ── B: Template literal with expressions ──────────────────────────────────
+  // Currently the plugin skips any TemplateLiteral whose .expressions.length > 0.
+  // The expected output reconstructs the container as a React fragment:
+  //   {`hello ${name}`}  →  <><WuTranslate __i18nKey="hello" />{name}</>
+  //
+  // All tests in this group are expected to FAIL until the feature lands.
+
+  describe("B: Template literal with expressions", () => {
+    it("B1. text before dynamic  →  wraps leading quasi, keeps expr", () => {
+      // {`hello ${name}`}  →  <><WuTranslate __i18nKey="hello" />{name}</>
+      const code = "<WuButton>{`hello ${name}`}</WuButton>";
+      const result = transform(code);
+      expect(result).toContain(`<WuTranslate __i18nKey="hello"></WuTranslate>`);
+      expect(result).toContain(`{name}`);
+      expect(result).not.toContain('__i18nKey="name"');
+    });
+
+    it("B2. dynamic before text  →  keeps expr, wraps trailing quasi", () => {
+      // {`${name} how are you`}  →  <>{name}<WuTranslate __i18nKey="how are you" /></>
+      const code = "<WuButton>{`${name} how are you`}</WuButton>";
+      const result = transform(code);
+      expect(result).toContain(
+        `<WuTranslate __i18nKey="how are you"></WuTranslate>`,
+      );
+      expect(result).toContain(`{name}`);
+    });
+
+    it("B3. text + dynamic + text  →  wraps both quasis, keeps expr in between", () => {
+      // {`hello ${name} how are you`}
+      //   → <><WuTranslate __i18nKey="hello" />{name}<WuTranslate __i18nKey="how are you" /></>
+      const code = "<WuButton>{`hello ${name} how are you`}</WuButton>";
+      const result = transform(code);
+      expect(result).toContain(`<WuTranslate __i18nKey="hello"></WuTranslate>`);
+      expect(result).toContain(
+        `<WuTranslate __i18nKey="how are you"></WuTranslate>`,
+      );
+      expect(result).toContain(`{name}`);
+    });
+
+    it("B4. two dynamics with static text between  →  wraps middle quasi only", () => {
+      // {`${a} and ${b}`}  →  <>{a}<WuTranslate __i18nKey="and" />{b}</>
+      const code = "<WuButton>{`${a} and ${b}`}</WuButton>";
+      const result = transform(code);
+      expect(result).toContain(`<WuTranslate __i18nKey="and"></WuTranslate>`);
+      expect(result).toContain(`{a}`);
+      expect(result).toContain(`{b}`);
+    });
+
+    it("B5. text + two dynamics + text  →  wraps outer quasis and middle quasi", () => {
+      // {`hello ${a} and ${b} end`}
+      //   → <><WuTranslate key="hello" />{a}<WuTranslate key="and" />{b}<WuTranslate key="end" /></>
+      const code = "<WuButton>{`hello ${a} and ${b} end`}</WuButton>";
+      const result = transform(code);
+      expect(result).toContain(`<WuTranslate __i18nKey="hello"></WuTranslate>`);
+      expect(result).toContain(`<WuTranslate __i18nKey="and"></WuTranslate>`);
+      expect(result).toContain(`<WuTranslate __i18nKey="end"></WuTranslate>`);
+      expect(result).toContain(`{a}`);
+      expect(result).toContain(`{b}`);
+    });
+
+    it("B6. empty quasis between two dynamics  →  no key emitted for empty segment", () => {
+      // {`${a}${b}`}  →  <>{a}{b}</>
+      // quasis: ["", "", ""] — all empty, nothing to wrap
+      const code = "<WuButton>{`${a}${b}`}</WuButton>";
+      const result = transform(code);
+      // no translation key for empty/whitespace quasis
+      expect(result).not.toContain(`__i18nKey`);
+    });
+
+    it("B7. whitespace-only quasi between dynamics  →  not wrapped", () => {
+      // {`${a}   ${b}`}  →  <>{a}   {b}</>
+      const code = "<WuButton>{`${a}   ${b}`}</WuButton>";
+      const result = transform(code);
+      expect(result).not.toContain(`WuTranslate`);
+    });
+
+    it("B8. ignored component — template literal skipped entirely", () => {
+      const code = "<WuIcon>{`hello ${name}`}</WuIcon>";
+      const result = transform(code);
+      expect(result).not.toContain(`WuTranslate`);
+    });
+
+    it("B9. data-skip — template literal skipped entirely", () => {
+      const code = "<WuButton data-skip>{`hello ${name}`}</WuButton>";
+      const result = transform(code);
+      expect(result).not.toContain(`WuTranslate`);
+    });
+
+    it("B10. output is a React fragment wrapping the interleaved nodes", () => {
+      // the entire {`...`} container is replaced with <> ... </>
+      const code = "<WuButton>{`hello ${name}`}</WuButton>";
+      const result = transform(code);
+      expect(result).toMatch(/<>.*WuTranslate.*<\/>/s);
+    });
+  });
+});
+
+// ─── wt() call expressions ───────────────────────────────────────────────────────
+//
+// wt("static string") is a runtime lookup helper exposed from useTranslate().
+// The plugin’s job is to record static arguments into wick-ui-i18n.json so
+// they reach the translation API. No code transformation is performed.
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("wt() call expressions", () => {
+  it("W1. string literal arg is recorded in dictionary", () => {
+    const dict = getDictionary(`const text = wt("hello");`);
+    expect(dict).toHaveProperty("hello", "hello");
+  });
+
+  it("W2. static template literal arg is recorded", () => {
+    const dict = getDictionary("const text = wt(`hello`);");
+    expect(dict).toHaveProperty("hello", "hello");
+  });
+
+  it("W3. dynamic variable arg is ignored", () => {
+    const dict = getDictionary(`const text = wt(variable);`);
+    expect(dict).not.toHaveProperty("variable");
+  });
+
+  it("W4. template literal with expressions — static quasis extracted", () => {
+    // wt(`hello ${name}`) → `${wt("hello")} ${name}`
+    const dict = getDictionary("const text = wt(`hello ${name}`);");
+    expect(dict).toHaveProperty("hello", "hello");
+  });
+
+  it("W11. template literal — call is transformed into nested wt() calls", () => {
+    const result = transform("const text = wt(`hello ${name}`);");
+    expect(result).toContain('wt("hello")');
+    expect(result).not.toContain("wt(`hello ${name}`)");
+  });
+
+  it("W12. text before expr  →  leading quasi wrapped, expr kept", () => {
+    const result = transform("const t = wt(`hello ${name}`);");
+    expect(result).toContain('wt("hello")');
+    expect(result).toContain("${name}");
+  });
+
+  it("W13. text after expr  →  trailing quasi wrapped, expr kept", () => {
+    const result = transform("const t = wt(`${name} how are you`);");
+    expect(result).toContain('wt("how are you")');
+    expect(result).toContain("${name}");
+  });
+
+  it("W14. text + expr + text  →  both quasis wrapped, expr in between", () => {
+    const result = transform("const t = wt(`hello ${name} how are you`);");
+    expect(result).toContain('wt("hello")');
+    expect(result).toContain('wt("how are you")');
+    expect(result).toContain("${name}");
+  });
+
+  it("W15. only expressions, no static text  →  no transform", () => {
+    const result = transform("const t = wt(`${a}${b}`);");
+    expect(result).not.toContain("wt(\"");
+    // original call preserved as-is
+    expect(result).toContain("wt(`${a}${b}`)");
+  });
+
+  it("W16. whitespace-only quasi between exprs  →  no transform", () => {
+    const result = transform("const t = wt(`${a}   ${b}`);");
+    expect(result).not.toContain("wt(\"");
+  });
+
+  it("W5. multiple wt() calls in same file all recorded", () => {
+    const dict = getDictionary(`const a = wt("hello"); const b = wt("world");`);
+    expect(dict).toHaveProperty("hello", "hello");
+    expect(dict).toHaveProperty("world", "world");
+  });
+
+  it("W6. whitespace in arg is normalised", () => {
+    const dict = getDictionary(`const text = wt("hello  world");`);
+    expect(dict).toHaveProperty("hello world", "hello world");
+  });
+
+  it("W7. wt() call inside JSX expression is recorded", () => {
+    const dict = getDictionary(`<WuButton>{wt("hello")}</WuButton>`);
+    expect(dict).toHaveProperty("hello", "hello");
+  });
+
+  it("W8. code is not transformed — wt() call left as-is", () => {
+    const result = transform(`const text = wt("hello");`);
+    expect(result).not.toContain("WuTranslate");
+    expect(result).toContain(`wt("hello")`);
+  });
+
+  it("W9. wt() and JSX translations coexist in same file", () => {
+    const code = `<WuButton>{wt("save")}</WuButton>`;
+    const dict = getDictionary(code);
+    // wt() arg recorded
+    expect(dict).toHaveProperty("save", "save");
+    // code still not transformed (no WuTranslate wrapping the wt call)
+    const result = transform(code);
+    expect(result).toContain(`wt("save")`);
+  });
+
+  it("W10. empty string arg is ignored", () => {
+    const dict = getDictionary(`const text = wt("");`);
+    expect(Object.keys(dict)).toHaveLength(0);
+  });
 });