@npm-questionpro/wick-ui-i18n 2.0.0-next.9 → 2.0.0

package/src/{transformJSXTextWithEntities.js → transformReactTextWithEntities.js}

@@ -18,6 +18,7 @@
  */
 
 import {getComponentTree} from './debug.js'
+import {splitQuasi} from './utils.js'
 
 /**
  * Splits the raw source around HTML entities (capturing group keeps entities
@@ -26,33 +27,12 @@ import {getComponentTree} from './debug.js'
  * "Hello & World"  →  ["Hello ", "&", " World"]
  * "<Tag>"        →  ["", "<", "Tag", ">", ""]
  */
-const HTML_ENTITY_SPLIT_RE =
-  /(&(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);)/g
+const HTML_ENTITY_SPLIT_RE = /(&(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);)/g
 
 /**
  * Tests whether a single segment (from the split above) is itself an entity.
  */
-const HTML_ENTITY_SEGMENT_RE =
-  /^&(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);$/
-
-/**
- * Given a text segment, extract leading whitespace, the translatable core,
- * and trailing whitespace so spacing around entities is preserved.
- *
- * @param {string} raw
- * @returns {{ leading: string, text: string, trailing: string }}
- */
-function splitSegment(raw) {
-  const leading = raw.match(/^\s*/)[0]
-  const trailing = raw.match(/\s*$/)[0]
-  // Normalise internal whitespace to match handleCapture behaviour:
-  // newlines → single space, consecutive spaces → single space.
-  const text = raw
-    .slice(leading.length, raw.length - trailing.length)
-    .replace(/\n/g, ' ')
-    .replace(/\s{2,}/g, ' ')
-  return {leading, text, trailing}
-}
+const HTML_ENTITY_SEGMENT_RE = /^&(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);$/
 
 /**
  * Transform a JSXText node whose raw source contains at least one HTML entity.
@@ -73,13 +53,7 @@ function splitSegment(raw) {
  * @param {string}      id         - Source file path (for collision warnings).
  * @returns {boolean} `true` when a replacement was written.
  */
-export function transformJSXTextWithEntities(
-  path,
-  rawSource,
-  ms,
-  processor,
-  id,
-) {
+export function transformJsxTextWithEntities(path, rawSource, ms, processor, id) {
   if (!processor.shouldTranslate(path)) return false
 
   // data-i18n-key cannot span multiple split segments — warn and ignore it.
@@ -105,13 +79,12 @@ export function transformJSXTextWithEntities(
       // Raw entity — emit as-is, no translation key
       parts.push(seg)
     } else {
-      const {leading, text, trailing} = splitSegment(seg)
+      // splitQuasi normalises internal whitespace and separates leading/trailing padding
+      const {leading, text, trailing} = splitQuasi(seg)
 
       if (text) {
         processor.record(text, text, id, componentTree)
-        parts.push(
-          `${leading}<WuTranslate __i18nKey=${JSON.stringify(text)}></WuTranslate>${trailing}`,
-        )
+        parts.push(`${leading}<WuTranslate __i18nKey=${JSON.stringify(text)}></WuTranslate>${trailing}`)
         hasTranslatable = true
       } else {
         // Pure whitespace between / around entities — preserve as JSX text

package/src/transformTemplateLiteral.js

@@ -11,21 +11,7 @@
  */
 
 import {getComponentTree} from './debug.js'
-
-/**
- * Given a quasi's cooked string, extract leading whitespace, trimmed text,
- * and trailing whitespace as separate pieces so spacing is preserved in the
- * reconstructed JSX fragment.
- *
- * @param {string} raw - The cooked value of a TemplateElement.
- * @returns {{ leading: string, text: string, trailing: string }}
- */
-function splitQuasi(raw) {
-  const leading = raw.match(/^\s*/)[0]
-  const trailing = raw.match(/\s*$/)[0]
-  const text = raw.slice(leading.length, raw.length - trailing.length)
-  return {leading, text, trailing}
-}
+import {splitQuasi, HTML_ENTITY_RE} from './utils.js'
 
 /**
  * Transform a JSXExpressionContainer whose expression is a TemplateLiteral
@@ -35,6 +21,7 @@ function splitQuasi(raw) {
  *   → <><WuTranslate __i18nKey="hello" /> {name} <WuTranslate __i18nKey="how are you" /></>
  *
  * Quasis that are empty or whitespace-only are skipped (no key emitted).
+ * Quasis that contain HTML entities are emitted as plain text (not wrapped).
  * Leading/trailing whitespace within a quasi is preserved as JSX text around
  * the WuTranslate element so words don't run together after translation.
  *
@@ -45,13 +32,7 @@ function splitQuasi(raw) {
  * @param {string}      id         - Source file path (for collision warnings).
  * @returns {boolean} `true` when a replacement was written.
  */
-export function transformTemplateLiteralExpression(
-  path,
-  code,
-  ms,
-  processor,
-  id,
-) {
+export function transformTemplateLiteralExpression(path, code, ms, processor, id) {
   if (!processor.shouldTranslate(path)) return false
 
   const container = path.node
@@ -67,11 +48,14 @@ export function transformTemplateLiteralExpression(
     const {leading, text, trailing} = splitQuasi(cooked)
 
     if (text) {
-      processor.record(text, text, id, componentTree)
-      parts.push(
-        `${leading}<WuTranslate __i18nKey=${JSON.stringify(text)}></WuTranslate>${trailing}`,
-      )
-      hasTranslatable = true
+      if (HTML_ENTITY_RE.test(text)) {
+        // Entity-like string in this quasi — preserve as literal JSX text, no key
+        parts.push(cooked)
+      } else {
+        processor.record(text, text, id, componentTree)
+        parts.push(`${leading}<WuTranslate __i18nKey=${JSON.stringify(text)}></WuTranslate>${trailing}`)
+        hasTranslatable = true
+      }
     }
     // whitespace-only or empty quasi — emit nothing (no key, no node)
 

package/src/utils.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Shared utilities used across all transform modules:
+ * Babel traversal setup, constants, and text-normalisation helpers.
+ *
+ * Having a single source of truth here ensures every module applies
+ * identical normalisation and uses the same regex/plugin list.
+ */
+
+import _traverse from '@babel/traverse'
+
+/** @babel/traverse ESM/CJS interop — handles both `import traverse` forms. */
+export const traverse = _traverse.default || _traverse
+
+/** Babel parser plugins applied to every file. */
+export const BABEL_PLUGINS = ['jsx', 'typescript']
+
+/**
+ * Matches any HTML entity: named (&), decimal (©), or hex (©).
+ * 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 & → "&",   → "\u00a0", etc.).
+ */
+export const HTML_ENTITY_RE = /&(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);/
+
+/**
+ * Normalise a raw string: trim edges, then collapse newlines and whitespace
+ * runs to a single space. Applied to every string before it is used as a
+ * translation key so keys are stable regardless of source formatting.
+ *
+ * @param {string} raw
+ * @returns {string}
+ */
+export function normalise(raw) {
+  return raw
+    .trim()
+    .replace(/\n/g, ' ')
+    .replace(/\s{2,}/g, ' ')
+}
+
+/**
+ * Split a template quasi (or any padded string segment) into leading
+ * whitespace, normalised translatable text, and trailing whitespace.
+ *
+ * Leading/trailing whitespace is preserved separately so spacing around
+ * the replacement node is maintained in the reconstructed JSX output.
+ * The middle part is passed through `normalise` so keys are consistent.
+ *
+ * Used by both the JSX template-literal transformer and the wt() template
+ * transformer — a single shared implementation ensures the two paths
+ * produce identical keys for the same source text.
+ *
+ * @param {string} raw - Cooked value of a TemplateElement or a split text segment.
+ * @returns {{ leading: string, text: string, trailing: string }}
+ */
+export function splitQuasi(raw) {
+  const leading = raw.match(/^\s*/)[0]
+  const trailing = raw.match(/\s*$/)[0]
+  const text = normalise(raw.slice(leading.length, raw.length - trailing.length))
+  return {leading, text, trailing}
+}

package/src/transformWtCalls.js

@@ -1,136 +0,0 @@
-/**
- * @fileoverview transformWtCalls — detects wt("static string") call expressions
- * and records the argument as a translation key.
- *
- * No code transformation is performed. wt() handles runtime lookup via the
- * dictionary loaded by WuTranslateProvider. The plugin's only job here is to
- * ensure static arguments appear in wick-ui-i18n.json at build time so they
- * reach the translation API.
- *
- * Supported argument forms:
- *   wt("hello")         — StringLiteral
- *   wt(`hello`)         — TemplateLiteral with zero expressions
- *
- * Ignored:
- *   wt(variable)        — dynamic, cannot be statically analysed
- *   wt(`hello ${name}`) — has expressions, not fully static
- *   wt()  /  wt(a, b)   — wrong arity
- */
-
-/**
- * Extract leading whitespace, normalised text, and trailing whitespace from a
- * template quasi string. Mirrors the normalisation applied everywhere else in
- * the plugin (newlines → space, consecutive spaces → one space).
- *
- * @param {string} raw
- * @returns {{ leading: string, text: string, trailing: string }}
- */
-function splitQuasi(raw) {
-  const leading = raw.match(/^\s*/)[0]
-  const trailing = raw.match(/\s*$/)[0]
-  const text = raw
-    .slice(leading.length, raw.length - trailing.length)
-    .replace(/\n/g, ' ')
-    .replace(/\s{2,}/g, ' ')
-  return {leading, text, trailing}
-}
-
-/**
- * If `path` is a `wt(staticString)` call expression, record the key in the
- * processor dictionary. Returns `true` when a key was recorded.
- *
- * @param {import('@babel/traverse').NodePath} path  - CallExpression path.
- * @param {import('./processor.js').TranslationProcessor} processor
- * @param {string} id - Source file path (for collision warnings).
- * @returns {boolean}
- */
-export function recordWtCall(path, processor, id) {
-  const {callee, arguments: args} = path.node
-
-  // Only handle bare `wt(...)` identifiers — not obj.wt(...) etc.
-  if (callee.type !== 'Identifier' || callee.name !== 'wt') return false
-  if (args.length !== 1) return false
-
-  const arg = args[0]
-  let text = null
-
-  if (arg.type === 'StringLiteral') {
-    text = arg.value
-  } else if (arg.type === 'TemplateLiteral' && arg.expressions.length === 0) {
-    text = arg.quasis[0].value.cooked ?? arg.quasis[0].value.raw
-  }
-
-  if (text === null) return false
-
-  const cleanText = text
-    .trim()
-    .replace(/\n/g, ' ')
-    .replace(/\s{2,}/g, ' ')
-  if (!cleanText) return false
-
-  processor.record(cleanText, cleanText, id, '(wt)')
-  return true
-}
-
-/**
- * Transform a `wt(\`template ${expr} literal\`)` call whose template has one
- * or more dynamic expressions.
- *
- * Each static quasi is independently extracted and replaced with a nested
- * `wt("text")` call; dynamic expressions are preserved in place. The whole
- * `wt(\`...\`)` call is replaced with a plain template literal:
- *
- *   wt(`Hello ${name}`)        →  `${wt("Hello")} ${name}`
- *   wt(`${a} and ${b}`)        →  `${a} ${wt("and")} ${b}`
- *   wt(`Hello ${a} and ${b}`)  →  `${wt("Hello")} ${a} ${wt("and")} ${b}`
- *
- * If no quasi contains translatable text, the call is left untouched and the
- * function returns `false`.
- *
- * @param {import('@babel/traverse').NodePath} path - CallExpression path.
- * @param {string}      code   - Original source (for slicing expression text).
- * @param {import('magic-string').default} ms
- * @param {import('./processor.js').TranslationProcessor} processor
- * @param {string}      id     - Source file path.
- * @returns {boolean} `true` when the call was rewritten.
- */
-export function transformWtTemplateLiteral(path, code, ms, processor, id) {
-  const {callee, arguments: args} = path.node
-
-  if (callee.type !== 'Identifier' || callee.name !== 'wt') return false
-  if (args.length !== 1) return false
-
-  const arg = args[0]
-  if (arg.type !== 'TemplateLiteral' || arg.expressions.length === 0)
-    return false
-
-  const {quasis, expressions} = arg
-  const parts = ['`']
-  let hasTranslatable = false
-
-  for (let i = 0; i < quasis.length; i++) {
-    const cooked = quasis[i].value.cooked ?? quasis[i].value.raw
-    const {leading, text, trailing} = splitQuasi(cooked)
-
-    if (text) {
-      processor.record(text, text, id, '(wt)')
-      parts.push(`${leading}\${wt(${JSON.stringify(text)})}${trailing}`)
-      hasTranslatable = true
-    } else {
-      // empty or whitespace-only quasi — preserve as literal template text
-      parts.push(cooked)
-    }
-
-    if (i < expressions.length) {
-      const exprSrc = code.slice(expressions[i].start, expressions[i].end)
-      parts.push(`\${${exprSrc}}`)
-    }
-  }
-
-  parts.push('`')
-
-  if (!hasTranslatable) return false
-
-  ms.overwrite(path.node.start, path.node.end, parts.join(''))
-  return true
-}