@babelize/engine 0.0.0-stage → 0.1.0

package/dist/utils/icu-spans.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.branchSpanProblems = branchSpanProblems;
+exports.describeBranchSpanProblem = describeBranchSpanProblem;
+/**
+ * Per-branch check of the protected spans (tags, URLs, emails, code,
+ * never-translate terms) of an ICU translation. Shared by the translate
+ * phase and locale QA.
+ *
+ * Each combination of plural/select branches the translation can render
+ * (a "variant") must carry exactly the spans of the matching source variant:
+ * same branch keys where the source has them, the source's `other` branch for
+ * categories only the target language has, and the whole source when a plain
+ * source was turned into a plural. So `<b>` dropped from one branch, or kept
+ * in only one branch of an added plural, is caught — not just a span missing
+ * from every branch.
+ */
+const icu_message_1 = require("./icu-message");
+const placeholder_protection_1 = require("./placeholder-protection");
+/** Variants beyond this are not expanded (deeply nested selects); the check is skipped. */
+const MAX_VARIANTS = 256;
+class TooManyVariants extends Error {
+}
+function expand(nodes) {
+    let variants = [{ path: new Map(), text: '' }];
+    for (const node of nodes) {
+        if (node.type === 'text') {
+            for (const v of variants)
+                v.text += node.value;
+        }
+        else if (node.type === 'pound') {
+            for (const v of variants)
+                v.text += '#';
+        }
+        else if (node.type === 'argument') {
+            for (const v of variants)
+                v.text += `{${node.name}}`;
+        }
+        else {
+            const next = [];
+            for (const v of variants) {
+                for (const [key, branch] of Object.entries(node.options)) {
+                    for (const b of expand(branch)) {
+                        const path = new Map([...v.path, [node.name, key], ...b.path]);
+                        next.push({ path, text: v.text + b.text });
+                        if (next.length > MAX_VARIANTS)
+                            throw new TooManyVariants();
+                    }
+                }
+            }
+            variants = next;
+        }
+    }
+    return variants;
+}
+function spans(text, neverTranslate) {
+    const counts = new Map();
+    for (const t of (0, placeholder_protection_1.protectText)(text, neverTranslate, { icu: true }).tokens) {
+        const k = t.toLowerCase();
+        counts.set(k, (counts.get(k) ?? 0) + 1);
+    }
+    return counts;
+}
+/** The source variant a target variant is checked against. */
+function matchSource(source, target) {
+    const score = (s) => {
+        let exact = 0;
+        for (const [name, key] of s.path) {
+            const want = target.path.get(name);
+            if (want === key)
+                exact += 2;
+            else if (key !== 'other')
+                return -1;
+        }
+        return exact;
+    };
+    // Prefer the variant with the most matching branch keys; unmatched selectors fall back to `other`.
+    let best = source[0];
+    let bestScore = -Infinity;
+    for (const s of source) {
+        const sc = score(s);
+        if (sc > bestScore) {
+            best = s;
+            bestScore = sc;
+        }
+    }
+    return best;
+}
+function label(v) {
+    return v.path.size ? [...v.path].map(([n, k]) => `${n}=${k}`).join(', ') : 'message';
+}
+/** Span differences of `target` per branch combination (empty when fine). */
+function branchSpanProblems(source, target, neverTranslate = []) {
+    let src;
+    let tgt;
+    try {
+        src = expand((0, icu_message_1.parseIcu)(source));
+        tgt = expand((0, icu_message_1.parseIcu)(target));
+    }
+    catch {
+        // Unparseable (reported by the ICU checks) or too many branch combinations to expand.
+        return [];
+    }
+    const problems = new Map();
+    for (const t of tgt) {
+        const s = matchSource(src, t);
+        const want = spans(s.text, neverTranslate);
+        const have = spans(t.text, neverTranslate);
+        const lost = [];
+        const added = [];
+        for (const [span, n] of want)
+            if ((have.get(span) ?? 0) < n)
+                lost.push(span);
+        for (const [span, n] of have)
+            if ((want.get(span) ?? 0) < n)
+                added.push(span);
+        if (lost.length || added.length)
+            problems.set(label(t), { branch: label(t), lost, added });
+    }
+    return [...problems.values()];
+}
+/** "count=other: lost <b>, </b>" */
+function describeBranchSpanProblem(p) {
+    const parts = [p.lost.length ? `lost ${p.lost.join(', ')}` : '', p.added.length ? `added ${p.added.join(', ')}` : ''].filter(Boolean);
+    return `${p.branch}: ${parts.join('; ')}`;
+}

package/dist/utils/jsx-message.d.ts

@@ -0,0 +1,93 @@
+import * as t from '@babel/types';
+/**
+ * JSX sentences as one message.
+ *
+ * `<h1>Welcome back, {user}</h1>` used to be extracted as the fragment
+ * "Welcome back," and injected as `{t('…')} {user}`. A translation can't move
+ * words around a variable it never sees, and a count can't be pluralized. This
+ * module turns an element's mixed children — text, `{expressions}` and inline
+ * elements — into a single ICU message:
+ *
+ *   <h1>Welcome back, {user}</h1>                 → "Welcome back, {user}"
+ *   <p>Hi {user.name}</p>                         → "Hi {userName}"
+ *   <p>Total: {format(sum)} today</p>             → "Total: {0} today"
+ *   <p>Read the <Link href="/t">terms</Link></p>  → "Read the <link>terms</link>"
+ *   <p>You have {count} items</p>                 → "You have {count, plural, one {# item} other {# items}}"
+ *
+ * The extractor and the injector both call {@link buildJsxMessage} on the same
+ * untouched source, so they agree on the text (and so on the extraction id).
+ */
+export interface MessagePlaceholder {
+    kind: 'placeholder';
+    /** Argument name used in the message and in the values object. */
+    name: string;
+    expression: t.Expression;
+}
+export interface MessageTag {
+    kind: 'tag';
+    /** Tag name used in the message (`<link>…</link>`) and as the rich-text key. */
+    name: string;
+    element: t.JSXElement;
+}
+export interface JsxMessage {
+    /** The ICU message, e.g. "Welcome back, {user}". */
+    text: string;
+    /** Placeholders and tags in order of first appearance (each name once). */
+    entries: Array<MessagePlaceholder | MessageTag>;
+    /** Source nodes folded into the message (text, literal expressions, inline elements). */
+    consumed: t.Node[];
+    /** Name of the placeholder turned into an ICU plural, if any. */
+    plural?: string;
+}
+export type JsxMessageResult = {
+    kind: 'message';
+    message: JsxMessage;
+}
+/** Not a sentence: plain text, only expressions, block-level children, … */
+ | {
+    kind: 'none';
+}
+/** Reads like a sentence but can't be moved safely; extract fragments as before. */
+ | {
+    kind: 'unsafe';
+    reason: string;
+};
+/**
+ * Names that suggest a React node rather than text or a number — such a value
+ * can't be a message argument. Matched case-insensitively against the last
+ * name segment (`user.avatar`, `statusIcon`, `renderBadge()`). Extendable.
+ */
+export declare const ELEMENT_LIKE_NAMES: RegExp[];
+/** Rendered text of a JSXText node, with JSX's whitespace rules (same as Babel's cleanJSXElementLiteralChild). */
+export declare function cleanJsxText(value: string): string;
+/**
+ * Whether the expression is very likely a string or number. Message values
+ * must be: next-intl throws on a React element, i18next prints [object Object].
+ */
+export declare function isLikelyPrimitive(expr: t.Node): boolean;
+/**
+ * Build the single message for `node`'s children, or say why there is none.
+ * Pure: reads the AST, never changes it.
+ */
+export declare function buildJsxMessage(node: t.JSXElement | t.JSXFragment, options?: {
+    /**
+     * Turn "{count} items" into an ICU plural. Only when an LLM translator is
+     * configured: the NLLB service can't translate ICU plural messages.
+     */
+    plurals?: boolean;
+}): JsxMessageResult;
+/**
+ * Text used to name the key: the message without arguments and tags, with a
+ * plural's `other` branch standing in for it. "Welcome back, {user}" →
+ * "Welcome back,"; "{count, plural, one {# item} other {# items}} left" → "items left".
+ */
+export declare function messageKeyText(message: string): string;
+/** `{ user, userName: user.name, 0: format(x) }` — placeholders only. */
+export declare function placeholderValues(message: JsxMessage): t.ObjectProperty[];
+/** next-intl rich values: `b: (chunks) => <b>{chunks}</b>`. Moves the element into the callback. */
+export declare function richTagValue(tag: MessageTag): t.ObjectProperty;
+/** react-i18next Trans components: `b: <b />`. */
+export declare function transComponent(tag: MessageTag): t.ObjectProperty;
+export declare function hasTags(message: JsxMessage): boolean;
+/** `t("key")` or `t("key", { …values })`. */
+export declare function createMessageTCall(key: string, message: JsxMessage, callee?: t.Expression): t.CallExpression;