@babelize/engine 0.0.0-stage → 0.1.0

package/dist/utils/jsx-message.js

@@ -0,0 +1,621 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ELEMENT_LIKE_NAMES = void 0;
+exports.cleanJsxText = cleanJsxText;
+exports.isLikelyPrimitive = isLikelyPrimitive;
+exports.buildJsxMessage = buildJsxMessage;
+exports.messageKeyText = messageKeyText;
+exports.placeholderValues = placeholderValues;
+exports.richTagValue = richTagValue;
+exports.transComponent = transComponent;
+exports.hasTags = hasTags;
+exports.createMessageTCall = createMessageTCall;
+const generator_1 = __importDefault(require("@babel/generator"));
+const t = __importStar(require("@babel/types"));
+const string_utils_1 = require("./string-utils");
+/** Phrasing elements that live inside a sentence. Anything else is block-level. */
+const INLINE_TAGS = new Set([
+    'a', 'abbr', 'b', 'bdi', 'bdo', 'cite', 'code', 'data', 'del', 'dfn', 'em', 'i', 'ins', 'kbd',
+    'mark', 'q', 's', 'samp', 'small', 'span', 'strong', 'sub', 'sup', 'time', 'u', 'var',
+]);
+/** react-i18next's Trans, and the alias the injector uses when `Trans` is taken. */
+const TRANS_NAMES = new Set(['Trans', 'BabelizeTrans']);
+/** Elements whose text must not be rewritten as a whole. */
+const OPAQUE_PARENTS = new Set(['code', 'pre', 'script', 'style', 'svg', 'textarea']);
+/**
+ * i18next reads these from the options object of `t(key, options)`, so a
+ * placeholder can't use them as its name.
+ */
+const RESERVED_NAMES = new Set([
+    'context', 'defaultValue', 'fallbackLng', 'interpolation', 'joinArrays', 'keySeparator', 'lng', 'lngs',
+    'ns', 'nsSeparator', 'ordinal', 'postProcess', 'replace', 'returnDetails', 'returnObjects', 'skipInterpolation',
+]);
+const COUNT_NAME = /^(?:count|total|num|n|length)$|(?:Count|Length)$/;
+/** Words ending in "s" that are not regular plural nouns. */
+const NOT_PLURAL_NOUNS = new Set([
+    'is', 'was', 'has', 'does', 'this', 'its', 'his', 'hers', 'ours', 'yours', 'theirs', 'us', 'yes', 'plus',
+    'minus', 'thus', 'always', 'perhaps', 'across', 'besides', 'towards', 'news', 'series', 'species',
+]);
+/** "-ies" plurals whose singular ends in "y". Other "-ies" words are only handled when listed below. */
+const IES_TO_Y = new Set([
+    'activities', 'batteries', 'bodies', 'categories', 'cities', 'communities', 'companies', 'copies', 'countries',
+    'currencies', 'deliveries', 'dependencies', 'directories', 'entries', 'factories', 'families', 'galleries',
+    'histories', 'inquiries', 'libraries', 'parties', 'penalties', 'policies', 'priorities', 'properties', 'queries',
+    'replies', 'repositories', 'stories', 'strategies', 'studies', 'subsidiaries', 'summaries', 'technologies',
+    'territories', 'universities', 'utilities', 'varieties',
+]);
+/** "-ies" plurals that just drop the "s". */
+const IES_DROP_S = new Set([
+    'brownies', 'calories', 'cookies', 'goalies', 'hippies', 'lies', 'movies', 'pies', 'rookies', 'selfies',
+    'smoothies', 'ties', 'zombies',
+]);
+/**
+ * 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.
+ */
+exports.ELEMENT_LIKE_NAMES = [
+    /^(?:icon|badge|avatar|children|component|content|slot)$/i,
+    /(?:icon|badge|element|node|component)$/i,
+    /^render/i,
+];
+/** Calls that return text: formatters and conversions. */
+const TEXT_CALLS = [/^format/i, /^to\w*String$/, /^toFixed$/, /^toPrecision$/, /^toLocale/, /^String$/, /^Number$/, /^t$/];
+/** Words that may follow a counted noun without agreeing with it. */
+const SAFE_AFTER_NOUN = new Set([
+    'in', 'on', 'at', 'for', 'from', 'to', 'of', 'with', 'by', 'per', 'left', 'remaining', 'selected', 'found',
+    'added', 'removed', 'total', 'ago', 'available', 'pending', 'unread', 'online', 'away', 'and', 'or', 'so', 'out',
+]);
+/** Rendered text of a JSXText node, with JSX's whitespace rules (same as Babel's cleanJSXElementLiteralChild). */
+function cleanJsxText(value) {
+    const lines = value.split(/\r\n|\n|\r/);
+    let lastNonEmptyLine = 0;
+    for (let i = 0; i < lines.length; i++)
+        if (/[^ \t]/.test(lines[i]))
+            lastNonEmptyLine = i;
+    let out = '';
+    for (let i = 0; i < lines.length; i++) {
+        const isFirst = i === 0;
+        const isLast = i === lines.length - 1;
+        let line = lines[i].replace(/\t/g, ' ');
+        if (!isFirst)
+            line = line.replace(/^[ ]+/, '');
+        if (!isLast)
+            line = line.replace(/[ ]+$/, '');
+        if (line) {
+            if (i !== lastNonEmptyLine)
+                line += ' ';
+            out += line;
+        }
+    }
+    return out;
+}
+class NotASentence extends Error {
+}
+const code = (node) => (0, generator_1.default)(node, { compact: true, comments: false }).code;
+function lowerFirst(s) {
+    return s.charAt(0).toLowerCase() + s.slice(1);
+}
+function isSafeName(name) {
+    return /^[A-Za-z][A-Za-z0-9_]*$/.test(name);
+}
+/** `user` → user, `user.name` → userName, `props.user.name` → userName; anything else → null. */
+function placeholderNameFor(expr) {
+    if (t.isIdentifier(expr))
+        return isSafeName(expr.name) ? expr.name : null;
+    const parts = [];
+    let cur = expr;
+    while (t.isMemberExpression(cur) || t.isOptionalMemberExpression(cur)) {
+        if (cur.computed || !t.isIdentifier(cur.property))
+            return null;
+        parts.unshift(cur.property.name);
+        cur = cur.object;
+    }
+    if (t.isThisExpression(cur)) {
+        // this.props.x / this.state.x
+    }
+    else if (t.isIdentifier(cur)) {
+        parts.unshift(cur.name);
+    }
+    else {
+        return null;
+    }
+    while (parts.length > 1 && (parts[0] === 'props' || parts[0] === 'state'))
+        parts.shift();
+    if (parts.length === 0)
+        return null;
+    const name = parts.map((p, i) => (i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1))).join('');
+    return isSafeName(name) ? name : null;
+}
+/** `t('…')`, `t.rich(…)`, `i18n.t(…)`, `$t(…)` — already translated. */
+function isTranslationCall(node) {
+    if (!t.isCallExpression(node))
+        return false;
+    const callee = node.callee;
+    if (t.isIdentifier(callee))
+        return callee.name === 't' || callee.name === '$t';
+    if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
+        if (callee.property.name === 't')
+            return true;
+        return t.isIdentifier(callee.object) && callee.object.name === 't';
+    }
+    return false;
+}
+/** Walk an expression (not into nested functions' bodies for side effects). */
+function scanExpression(expr) {
+    const found = {};
+    const visit = (node, inFunction) => {
+        if (!node || typeof node !== 'object')
+            return;
+        if (isTranslationCall(node))
+            found.translated = true;
+        if (t.isJSXElement(node) || t.isJSXFragment(node))
+            found.jsx = true;
+        if (!inFunction) {
+            if (t.isAssignmentExpression(node))
+                found.sideEffect ?? (found.sideEffect = 'an assignment');
+            else if (t.isUpdateExpression(node))
+                found.sideEffect ?? (found.sideEffect = `${node.operator}`);
+            else if (t.isAwaitExpression(node))
+                found.sideEffect ?? (found.sideEffect = 'await');
+            else if (t.isYieldExpression(node))
+                found.sideEffect ?? (found.sideEffect = 'yield');
+            else if (t.isUnaryExpression(node) && node.operator === 'delete')
+                found.sideEffect ?? (found.sideEffect = 'delete');
+        }
+        const fn = inFunction || t.isFunction(node);
+        for (const key of t.VISITOR_KEYS[node.type] ?? []) {
+            const child = node[key];
+            if (Array.isArray(child))
+                child.forEach((c) => visit(c, fn));
+            else
+                visit(child, fn);
+        }
+    };
+    visit(expr, false);
+    return found;
+}
+function calleeName(callee) {
+    if (t.isIdentifier(callee))
+        return callee.name;
+    if ((t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) && !callee.computed && t.isIdentifier(callee.property))
+        return callee.property.name;
+    return null;
+}
+/** Name of an identifier / member expression's last segment (`user.avatar` → avatar). */
+function lastSegment(expr) {
+    if (t.isIdentifier(expr))
+        return expr.name;
+    if ((t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr)) && !expr.computed && t.isIdentifier(expr.property))
+        return expr.property.name;
+    return null;
+}
+const looksLikeElement = (name) => exports.ELEMENT_LIKE_NAMES.some((re) => re.test(name));
+/**
+ * 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].
+ */
+function isLikelyPrimitive(expr) {
+    if (t.isTSNonNullExpression(expr) || t.isTSAsExpression(expr) || t.isTSSatisfiesExpression(expr) || t.isParenthesizedExpression(expr)) {
+        return isLikelyPrimitive(expr.expression);
+    }
+    if (t.isNumericLiteral(expr) || t.isStringLiteral(expr) || t.isTemplateLiteral(expr))
+        return true;
+    if (t.isIdentifier(expr) || t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr)) {
+        const name = lastSegment(expr);
+        return !!name && !looksLikeElement(name);
+    }
+    if (t.isCallExpression(expr) || t.isOptionalCallExpression(expr)) {
+        const name = calleeName(expr.callee);
+        return !!name && TEXT_CALLS.some((re) => re.test(name));
+    }
+    if (t.isBinaryExpression(expr)) {
+        if (['-', '*', '/', '%', '**'].includes(expr.operator))
+            return true;
+        return expr.operator === '+' && isLikelyPrimitive(expr.left) && isLikelyPrimitive(expr.right);
+    }
+    if (t.isUnaryExpression(expr))
+        return expr.operator === '-' || expr.operator === '+';
+    if (t.isConditionalExpression(expr))
+        return isLikelyPrimitive(expr.consequent) && isLikelyPrimitive(expr.alternate);
+    if (t.isLogicalExpression(expr))
+        return expr.operator !== '&&' && isLikelyPrimitive(expr.left) && isLikelyPrimitive(expr.right);
+    return false;
+}
+/** A plain `count` / `cart.items.length` — no optional chain, call or fallback that could make it undefined. */
+function isPlainReference(expr) {
+    if (t.isIdentifier(expr))
+        return true;
+    return t.isMemberExpression(expr) && !expr.computed && t.isIdentifier(expr.property) && isPlainReference(expr.object);
+}
+/** `children` / `props.children`: React nodes, not message values. */
+function isChildren(expr) {
+    if (t.isIdentifier(expr))
+        return expr.name === 'children';
+    return (t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr)) && !expr.computed && t.isIdentifier(expr.property) && expr.property.name === 'children';
+}
+function elementName(el) {
+    const n = el.openingElement.name;
+    if (t.isJSXIdentifier(n))
+        return { intrinsic: /^[a-z]/.test(n.name), name: n.name };
+    if (t.isJSXMemberExpression(n))
+        return { intrinsic: false, name: n.property.name };
+    return null;
+}
+function hasContent(children) {
+    return children.some((c) => !(t.isJSXText(c) && cleanJsxText(c.value) === '') && !(t.isJSXExpressionContainer(c) && t.isJSXEmptyExpression(c.expression) && !c.expression.innerComments?.length));
+}
+/**
+ * Build the single message for `node`'s children, or say why there is none.
+ * Pure: reads the AST, never changes it.
+ */
+function buildJsxMessage(node, options = {}) {
+    if (t.isJSXElement(node)) {
+        const own = elementName(node);
+        if (!own || (own.intrinsic && OPAQUE_PARENTS.has(own.name)) || TRANS_NAMES.has(own.name))
+            return { kind: 'none' };
+    }
+    // Cheap pre-check: a sentence has more than one child, not all of them text.
+    const kids = node.children;
+    if (kids.length < 2 || kids.every((c) => t.isJSXText(c)))
+        return { kind: 'none' };
+    const entries = [];
+    const consumed = [];
+    const phByCode = new Map();
+    const tagByCode = new Map();
+    const usedNames = new Set();
+    let complexIndex = 0;
+    let unsafe;
+    let voidElement;
+    let placeholderCount = 0;
+    let tagCount = 0;
+    const uniqueName = (base) => {
+        let name = base;
+        for (let n = 2; usedNames.has(name); n++)
+            name = `${base}${n}`;
+        usedNames.add(name);
+        return name;
+    };
+    const addPlaceholder = (expr) => {
+        const simple = placeholderNameFor(expr);
+        const exprCode = code(expr);
+        if (simple) {
+            const existing = phByCode.get(exprCode);
+            if (existing)
+                return existing;
+        }
+        let name;
+        if (simple) {
+            name = uniqueName(RESERVED_NAMES.has(simple) ? `${simple}Value` : simple);
+            phByCode.set(exprCode, name);
+        }
+        else {
+            while (usedNames.has(String(complexIndex)))
+                complexIndex++;
+            name = String(complexIndex++);
+            usedNames.add(name);
+        }
+        entries.push({ kind: 'placeholder', name, expression: expr });
+        return name;
+    };
+    const walk = (children, depth) => {
+        const pieces = [];
+        for (const child of children) {
+            if (t.isJSXText(child)) {
+                const text = cleanJsxText(child.value);
+                consumed.push(child);
+                if (text)
+                    pieces.push({ type: 'text', value: text });
+                continue;
+            }
+            if (t.isJSXExpressionContainer(child)) {
+                const expr = child.expression;
+                if (t.isJSXEmptyExpression(expr)) {
+                    if (expr.innerComments?.length)
+                        unsafe ?? (unsafe = 'it contains a {/* comment */}');
+                    continue;
+                }
+                if (t.isStringLiteral(expr)) {
+                    consumed.push(expr);
+                    pieces.push({ type: 'text', value: expr.value });
+                    continue;
+                }
+                if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) {
+                    consumed.push(expr);
+                    pieces.push({ type: 'text', value: expr.quasis[0].value.cooked ?? expr.quasis[0].value.raw });
+                    continue;
+                }
+                const scan = scanExpression(expr);
+                if (scan.translated)
+                    throw new NotASentence();
+                placeholderCount++;
+                if (scan.sideEffect)
+                    unsafe ?? (unsafe = `{${code(expr)}} has a side effect (${scan.sideEffect})`);
+                else if (scan.jsx)
+                    unsafe ?? (unsafe = `{${code(expr)}} renders elements`);
+                else if (isChildren(expr))
+                    unsafe ?? (unsafe = `{${code(expr)}} passes children through`);
+                else if (!isLikelyPrimitive(expr))
+                    unsafe ?? (unsafe = `{${code(expr)}} may be an element, not text or a number`);
+                if (unsafe)
+                    continue;
+                pieces.push({ type: 'ph', name: addPlaceholder(expr) });
+                continue;
+            }
+            if (t.isJSXElement(child)) {
+                const info = elementName(child);
+                if (!info || (info.intrinsic && !INLINE_TAGS.has(info.name)) || TRANS_NAMES.has(info.name))
+                    throw new NotASentence();
+                if (!hasContent(child.children)) {
+                    voidElement ?? (voidElement = `<${info.name} />`);
+                    continue;
+                }
+                const spread = child.openingElement.attributes.find((a) => t.isJSXSpreadAttribute(a));
+                if (spread) {
+                    if (depth === 0)
+                        tagCount++;
+                    unsafe ?? (unsafe = `<${info.name}> spreads props`);
+                    continue;
+                }
+                for (const attr of child.openingElement.attributes) {
+                    if (t.isJSXAttribute(attr) && t.isJSXExpressionContainer(attr.value) && !t.isJSXEmptyExpression(attr.value.expression)) {
+                        const scan = scanExpression(attr.value.expression);
+                        if (scan.sideEffect)
+                            unsafe ?? (unsafe = `an attribute of <${info.name}> has a side effect (${scan.sideEffect})`);
+                    }
+                }
+                if (depth === 0)
+                    tagCount++;
+                consumed.push(child);
+                const inner = walk(child.children, depth + 1);
+                const shell = code({ ...child.openingElement, selfClosing: true });
+                let name = tagByCode.get(shell);
+                if (!name) {
+                    name = uniqueName(lowerFirst(info.name).replace(/[^A-Za-z0-9]/g, '') || 'tag');
+                    tagByCode.set(shell, name);
+                    entries.push({ kind: 'tag', name, element: child });
+                }
+                pieces.push({ type: 'tag', name, children: inner });
+                continue;
+            }
+            // Fragments and {...spread} children: leave the element alone.
+            throw new NotASentence();
+        }
+        return pieces;
+    };
+    let pieces;
+    try {
+        pieces = walk(node.children, 0);
+    }
+    catch (e) {
+        if (e instanceof NotASentence)
+            return { kind: 'none' };
+        throw e;
+    }
+    const literal = collectText(pieces).replace(/\s+/g, ' ').trim();
+    if (!(0, string_utils_1.isTranslatableText)(literal) || (0, string_utils_1.containsPII)(literal))
+        return { kind: 'none' };
+    const meaningful = pieces.filter((p) => p.type !== 'text' || p.value.trim() !== '');
+    const isSentence = placeholderCount + tagCount > 0 && (meaningful.length >= 2 || placeholderCount > 0);
+    if (!isSentence)
+        return { kind: 'none' };
+    if (unsafe)
+        return { kind: 'unsafe', reason: unsafe };
+    if (voidElement)
+        return { kind: 'unsafe', reason: `${voidElement} has no text to wrap` };
+    if (meaningful.length < 2)
+        return { kind: 'none' };
+    if (/[{}<>]/.test(collectText(pieces))) {
+        return { kind: 'unsafe', reason: 'the text contains { } < or >, which are message syntax' };
+    }
+    const plural = options.plurals === false ? undefined : makePlural(pieces, entries);
+    // JSX text was already cleaned by the JSX rules; collapse leftover runs of
+    // ASCII whitespace (HTML renders them as one space) but keep &nbsp; and the
+    // spaces inside inline elements. Outer edge spaces are kept by the injector.
+    const text = serialize(pieces).replace(/[ \t\r\n]+/g, ' ').replace(/^[ \t\r\n]+|[ \t\r\n]+$/g, '');
+    return { kind: 'message', message: { text, entries, consumed, plural } };
+}
+function collectText(pieces) {
+    return pieces.map((p) => (p.type === 'text' ? p.value : p.type === 'tag' ? collectText(p.children) : ' ')).join('');
+}
+function serialize(pieces) {
+    let out = '';
+    pieces.forEach((p, i) => {
+        if (p.type === 'text') {
+            let value = p.value;
+            // An apostrophe right before `{` or `<` would start an ICU quote.
+            if (value.endsWith("'") && i + 1 < pieces.length && pieces[i + 1].type !== 'text')
+                value += "'";
+            out += value;
+        }
+        else if (p.type === 'ph') {
+            out += `{${p.name}}`;
+        }
+        else if (p.type === 'plural') {
+            out += `{${p.name}, plural, one {# ${p.one}} other {# ${p.other}}}`;
+        }
+        else {
+            const inner = serialize(p.children);
+            out += `<${p.name}>${inner}</${p.name}>`;
+        }
+    });
+    return out;
+}
+function singular(word) {
+    if (word.length < 3 || !/^[a-z]+s$/.test(word) || NOT_PLURAL_NOUNS.has(word))
+        return null;
+    if (/(?:ss|us|is)$/.test(word))
+        return null;
+    if (word.endsWith('ies')) {
+        if (IES_TO_Y.has(word))
+            return word.slice(0, -3) + 'y';
+        if (IES_DROP_S.has(word))
+            return word.slice(0, -1);
+        return null; // unsure: keep a plain placeholder
+    }
+    if (/(?:sses|shes|ches|xes|zes)$/.test(word))
+        return word.slice(0, -2);
+    return word.slice(0, -1);
+}
+/**
+ * `{count} items` → `{count, plural, one {# item} other {# items}}`, only when
+ * it is unambiguous: one count-like placeholder, used once, directly followed
+ * by a regular plural noun that ends the sentence or is followed by a word
+ * that doesn't agree with it ("in", "left", "selected", …).
+ */
+function makePlural(pieces, entries) {
+    const countLike = entries.filter((e) => e.kind === 'placeholder' && COUNT_NAME.test(e.name));
+    if (countLike.length !== 1)
+        return undefined;
+    // `data?.count` or `n ?? 0` may be undefined at runtime → "NaN items".
+    if (!isPlainReference(countLike[0].expression))
+        return undefined;
+    const name = countLike[0].name;
+    const uses = countUses(pieces, name);
+    if (uses !== 1)
+        return undefined;
+    const visit = (list) => {
+        for (let i = 0; i < list.length; i++) {
+            const p = list[i];
+            if (p.type === 'tag' && visit(p.children))
+                return true;
+            if (p.type !== 'ph' || p.name !== name)
+                continue;
+            const next = list[i + 1];
+            if (!next || next.type !== 'text')
+                return false;
+            const m = /^ ([a-z]+)(?=$|[\s.,!?;:)])/.exec(next.value);
+            if (!m)
+                return false;
+            const one = singular(m[1]);
+            if (!one)
+                return false;
+            const rest = next.value.slice(m[0].length);
+            const after = /^\s*([A-Za-z]+)/.exec(rest);
+            const restOfSentence = rest + collectText(list.slice(i + 2));
+            if (after && !SAFE_AFTER_NOUN.has(after[1].toLowerCase()))
+                return false;
+            if (!after && /[A-Za-z]/.test(restOfSentence))
+                return false;
+            list.splice(i, 2, { type: 'plural', name, one, other: m[1] }, { type: 'text', value: rest });
+            return true;
+        }
+        return false;
+    };
+    return visit(pieces) ? name : undefined;
+}
+function countUses(pieces, name) {
+    let n = 0;
+    for (const p of pieces) {
+        if (p.type === 'ph' && p.name === name)
+            n++;
+        if (p.type === 'tag')
+            n += countUses(p.children, name);
+    }
+    return n;
+}
+/**
+ * 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".
+ */
+function messageKeyText(message) {
+    return message
+        .replace(/\{\s*\w+\s*,\s*plural\s*,[^{}]*?(?:\{[^{}]*\}[^{}]*?)*\}/g, (m) => {
+        const other = /other\s*\{([^{}]*)\}/.exec(m);
+        return other ? ` ${other[1].replace(/#/g, '')} ` : ' ';
+    })
+        .replace(/\{[^{}]*\}/g, ' ')
+        .replace(/<\/?[A-Za-z][\w-]*>/g, '')
+        .replace(/''/g, "'")
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+// ── Code generation (shared by the injection strategies) ─────────────────────
+/** A parameter name for rich-text callbacks that the element doesn't already use. */
+function chunksParam(el) {
+    const text = code(el);
+    for (const candidate of ['chunks', '_chunks', '__chunks']) {
+        if (!new RegExp(`\\b${candidate}\\b`).test(text))
+            return candidate;
+    }
+    return '__chunks';
+}
+function propertyKey(name) {
+    return /^\d+$/.test(name) ? t.numericLiteral(Number(name)) : t.identifier(name);
+}
+/** `{ user, userName: user.name, 0: format(x) }` — placeholders only. */
+function placeholderValues(message) {
+    return message.entries
+        .filter((e) => e.kind === 'placeholder')
+        .map((e) => {
+        const shorthand = t.isIdentifier(e.expression) && e.expression.name === e.name;
+        return t.objectProperty(propertyKey(e.name), e.expression, false, shorthand);
+    });
+}
+/** next-intl rich values: `b: (chunks) => <b>{chunks}</b>`. Moves the element into the callback. */
+function richTagValue(tag) {
+    const param = chunksParam(tag.element);
+    const el = tag.element;
+    el.children = [t.jsxExpressionContainer(t.identifier(param))];
+    if (!el.closingElement) {
+        el.openingElement.selfClosing = false;
+        el.closingElement = t.jsxClosingElement(el.openingElement.name);
+    }
+    return t.objectProperty(t.identifier(tag.name), t.arrowFunctionExpression([t.identifier(param)], el));
+}
+/** react-i18next Trans components: `b: <b />`. */
+function transComponent(tag) {
+    const el = tag.element;
+    el.children = [];
+    el.openingElement.selfClosing = true;
+    el.closingElement = null;
+    return t.objectProperty(t.identifier(tag.name), el);
+}
+function hasTags(message) {
+    return message.entries.some((e) => e.kind === 'tag');
+}
+/** `t("key")` or `t("key", { …values })`. */
+function createMessageTCall(key, message, callee = t.identifier('t')) {
+    const values = placeholderValues(message);
+    const args = [t.stringLiteral(key)];
+    if (values.length > 0)
+        args.push(t.objectExpression(values));
+    return t.callExpression(callee, args);
+}

package/dist/utils/key-usage.d.ts

@@ -0,0 +1,35 @@
+import type { KeyUsageReport, WorkspaceInfo } from '../runtime/types';
+/**
+ * Which translation keys the project's code still references.
+ *
+ * Strings injected by earlier runs are no longer extracted, so the source
+ * locale file is the only list of keys — and it only ever grows. Keys whose
+ * string was deleted from the code would otherwise be translated into every
+ * new locale forever. This scans for the reference forms the injection
+ * strategies emit (and common hand-written ones):
+ *
+ *   t('key') / t("key") / t(`key`)        react-i18next, next-intl, vue-i18n, vanilla
+ *   $t('key'), i18n.t('key'), t.rich/markup/raw/has('key')
+ *   i18nKey="key"                          react-i18next <Trans>
+ *   data-i18n="key", data-i18n-<attr>="key"  static HTML
+ *
+ * and next-intl namespaces (`useTranslations('ns')`, `getTranslations('ns')`
+ * or `{ namespace: 'ns' }`), counting `t('k')` in such a file as `ns.k` too.
+ *
+ * Conservative by design: a call with a key it can't read statically
+ * (`t(variable)`, `t(\`a.${x}\`)`) marks the scan dynamic, and callers must
+ * then treat every key as live.
+ */
+export interface KeyUsage {
+    /** Keys referenced literally somewhere in the code. */
+    referenced: Set<string>;
+    /** Files with a translation call whose key isn't a literal (relative paths). */
+    dynamicFiles: string[];
+}
+export declare function scanKeyReferences(content: string): {
+    keys: string[];
+    dynamic: boolean;
+};
+export declare function findKeyUsage(workspace: WorkspaceInfo): Promise<KeyUsage>;
+/** Report-only: source keys with no t() reference found. Never used to skip or drop anything. */
+export declare function reportKeyUsage(workspace: WorkspaceInfo, sourceKeys: Record<string, string>, extractedNow: Set<string>): Promise<KeyUsageReport>;