@babelize/engine 0.1.2 → 0.2.0

package/dist/utils/icu-message.js

@@ -190,11 +190,29 @@ function pluralCategories(locale, type) {
         return [...CLDR_ORDER];
     }
 }
+/**
+ * Whole numbers (0–999) a plural category is used for, e.g. Czech few → 2, 3, 4,
+ * Czech many → none (only fractions like 1.5). CLDR integer rules repeat
+ * within every hundred, so this range covers them.
+ */
+function integersOf(locale, type, category) {
+    try {
+        const rules = new Intl.PluralRules(locale, { type });
+        const out = [];
+        for (let n = 0; n < 1000; n++)
+            if (rules.select(n) === category)
+                out.push(n);
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Compare a translated ICU message to its source. Errors mean the message is
  * broken at runtime (unparseable, arguments renamed, select branches changed,
- * no `other`). Missing target plural categories are only a warning: ICU
- * falls back to `other` for them.
+ * no `other`, a target plural category whole numbers use). A missing category
+ * only fractions use is a warning: ICU falls back to `other` for it.
  */
 function compareIcuMessages(source, translated, targetLocale, options = {}) {
     let sourceAst;
@@ -291,11 +309,29 @@ function compareIcuMessages(source, translated, targetLocale, options = {}) {
         }
         const missing = allowed.filter((c) => !target.keys.includes(c));
         if (missing.length) {
-            issues.push({
-                severity: 'warning',
-                code: 'icu_plural_category_missing',
-                message: `{${target.name}, ${target.kind}} has no [${missing.join(', ')}] branch for ${targetLocale}; "other" will be used`,
-            });
+            // A missing category whole numbers reach (Czech few: 2–4) shows the
+            // wrong form for common counts ("2 souborů"): an error. One only
+            // fractions reach (Czech many: 1.5), or whose numbers all have `=n`
+            // branches, falls back to `other` rarely: a warning.
+            const type = target.kind === 'selectordinal' ? 'ordinal' : 'cardinal';
+            const reached = missing
+                .map((c) => ({ c, ns: integersOf(targetLocale, type, c).filter((n) => !target.keys.includes(`=${n}`)) }))
+                .filter((m) => m.ns.length > 0);
+            if (reached.length) {
+                const examples = (ns) => `${ns.slice(0, 3).join(', ')}${ns.length > 3 ? ', …' : ''}`;
+                issues.push({
+                    severity: 'error',
+                    code: 'icu_plural_category_missing',
+                    message: `{${target.name}, ${target.kind}} has no ${reached.map((m) => `${m.c} branch (${examples(m.ns)})`).join(', ')} for ${targetLocale}; those counts would get the "other" form`,
+                });
+            }
+            else {
+                issues.push({
+                    severity: 'warning',
+                    code: 'icu_plural_category_missing',
+                    message: `{${target.name}, ${target.kind}} has no [${missing.join(', ')}] branch for ${targetLocale}; "other" will be used`,
+                });
+            }
         }
     }
     return issues;

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

@@ -10,7 +10,7 @@ import * as t from '@babel/types';
  *
  *   <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>Total: {format(sum)} today</p>             → "Total: {sum} 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}}"
  *
@@ -60,6 +60,21 @@ export type JsxMessageResult = {
 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;
+/**
+ * A name for an expression that isn't a plain variable, from the value it
+ * shows: `formatDate(deal.endsAt)` → dealEndsAt, `(n / 1000).toFixed(1)` → n,
+ * `status || 'Unknown'` → status. Null when nothing names it.
+ */
+export declare function derivedNameFor(expr: t.Node): string | null;
+/**
+ * `item{n === 1 ? '' : 's'}`: a suffix that pluralizes the word before it.
+ * The count, and the suffix for one and for other.
+ */
+export declare function pluralSuffix(expr: t.Node): {
+    count: t.Expression;
+    one: string;
+    other: string;
+} | null;
 /**
  * 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].

package/dist/utils/jsx-message.js

@@ -38,6 +38,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ELEMENT_LIKE_NAMES = void 0;
 exports.cleanJsxText = cleanJsxText;
+exports.derivedNameFor = derivedNameFor;
+exports.pluralSuffix = pluralSuffix;
 exports.isLikelyPrimitive = isLikelyPrimitive;
 exports.buildJsxMessage = buildJsxMessage;
 exports.messageKeyText = messageKeyText;
@@ -163,6 +165,57 @@ function placeholderNameFor(expr) {
     const name = parts.map((p, i) => (i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1))).join('');
     return isSafeName(name) ? name : null;
 }
+/**
+ * A name for an expression that isn't a plain variable, from the value it
+ * shows: `formatDate(deal.endsAt)` → dealEndsAt, `(n / 1000).toFixed(1)` → n,
+ * `status || 'Unknown'` → status. Null when nothing names it.
+ */
+function derivedNameFor(expr) {
+    const named = (e) => !e || !t.isExpression(e) ? null : placeholderNameFor(e) ?? derivedNameFor(e);
+    if (t.isCallExpression(expr) || t.isOptionalCallExpression(expr)) {
+        const callee = expr.callee;
+        // `price.toFixed(2)`, `date.toLocaleDateString()`: the value being formatted.
+        if ((t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) && !t.isIdentifier(callee.object, { name: 'Math' })) {
+            const own = named(callee.object);
+            if (own)
+                return own;
+        }
+        return named(expr.arguments[0]);
+    }
+    if (t.isLogicalExpression(expr) || t.isBinaryExpression(expr))
+        return named(expr.left) ?? named(expr.right);
+    if (t.isTSAsExpression(expr) || t.isTSNonNullExpression(expr) || t.isParenthesizedExpression(expr))
+        return named(expr.expression);
+    if (t.isUnaryExpression(expr))
+        return named(expr.argument);
+    return null;
+}
+/**
+ * `item{n === 1 ? '' : 's'}`: a suffix that pluralizes the word before it.
+ * The count, and the suffix for one and for other.
+ */
+function pluralSuffix(expr) {
+    if (!t.isConditionalExpression(expr) || !t.isStringLiteral(expr.consequent) || !t.isStringLiteral(expr.alternate))
+        return null;
+    const test = expr.test;
+    if (!t.isBinaryExpression(test) || !t.isExpression(test.left))
+        return null;
+    const isOne = (n) => t.isNumericLiteral(n, { value: 1 });
+    const count = isOne(test.right) ? test.left : isOne(test.left) ? test.right : null;
+    if (!count)
+        return null;
+    const yes = expr.consequent.value;
+    const no = expr.alternate.value;
+    if (!/^[a-z]{0,3}$/.test(yes) || !/^[a-z]{0,3}$/.test(no) || yes === no)
+        return null;
+    const flipped = isOne(test.left);
+    const op = flipped ? { '>': '<', '<': '>' }[test.operator] ?? test.operator : test.operator;
+    if (op === '===' || op === '==')
+        return { count, one: yes, other: no };
+    if (op === '!==' || op === '!=' || op === '>')
+        return { count, one: no, other: yes };
+    return null;
+}
 /** `t('…')`, `t.rich(…)`, `i18n.t(…)`, `$t(…)` — already translated. */
 function isTranslationCall(node) {
     if (!t.isCallExpression(node))
@@ -300,10 +353,10 @@ function buildJsxMessage(node, options = {}) {
     const phByCode = new Map();
     const tagByCode = new Map();
     const usedNames = new Set();
-    let complexIndex = 0;
     let unsafe;
     let voidElement;
     let placeholderCount = 0;
+    let suffixPlural;
     let tagCount = 0;
     const uniqueName = (base) => {
         let name = base;
@@ -326,10 +379,9 @@ function buildJsxMessage(node, options = {}) {
             phByCode.set(exprCode, name);
         }
         else {
-            while (usedNames.has(String(complexIndex)))
-                complexIndex++;
-            name = String(complexIndex++);
-            usedNames.add(name);
+            // Named after what it shows, so translators see `{dealEndsAt}`, not `{0}`.
+            const derived = derivedNameFor(expr);
+            name = uniqueName(derived && !RESERVED_NAMES.has(derived) ? derived : 'value');
         }
         entries.push({ kind: 'placeholder', name, expression: expr });
         return name;
@@ -361,6 +413,30 @@ function buildJsxMessage(node, options = {}) {
                     pieces.push({ type: 'text', value: expr.quasis[0].value.cooked ?? expr.quasis[0].value.raw });
                     continue;
                 }
+                // `application{n === 1 ? '' : 's'}`: one message with a plural, not "application{0}".
+                // The code already pluralizes, so this isn't the guess `plurals` gates: a sentence
+                // only exists with an ICU runtime, and every translator handles ICU plurals.
+                const suffix = pluralSuffix(expr);
+                const prev = pieces[pieces.length - 1];
+                const word = suffix && prev?.type === 'text' ? /([A-Za-z]+)$/.exec(prev.value) : null;
+                if (suffix && word && prev?.type === 'text' && scanExpression(suffix.count).sideEffect === undefined) {
+                    consumed.push(expr);
+                    placeholderCount++;
+                    const before = prev.value.slice(0, -word[1].length);
+                    const name = addPlaceholder(suffix.count);
+                    suffixPlural ?? (suffixPlural = name);
+                    const plural = { type: 'plural', name, one: word[1] + suffix.one, other: word[1] + suffix.other, hash: false };
+                    // `{n} application{…}`: the count goes inside the plural as `#`.
+                    const counted = before === ' ' && pieces[pieces.length - 2]?.type === 'ph' && pieces[pieces.length - 2].name === name;
+                    if (counted) {
+                        pieces.splice(pieces.length - 2, 2, { ...plural, hash: true });
+                    }
+                    else {
+                        prev.value = before;
+                        pieces.push(plural);
+                    }
+                    continue;
+                }
                 const scan = scanExpression(expr);
                 if (scan.translated)
                     throw new NotASentence();
@@ -446,12 +522,13 @@ function buildJsxMessage(node, options = {}) {
         return { kind: 'unsafe', reason: unsafe };
     if (voidElement)
         return { kind: 'unsafe', reason: `${voidElement} has no text to wrap` };
-    if (meaningful.length < 2)
+    // One piece is a sentence only when it's a plural: `{n} result{n !== 1 ? 's' : ''}`.
+    if (meaningful.length < 2 && !meaningful.some((p) => p.type === 'plural'))
         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);
+    const plural = (options.plurals === false ? undefined : makePlural(pieces, entries)) ?? suffixPlural;
     // 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.
@@ -459,7 +536,9 @@ function buildJsxMessage(node, options = {}) {
     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('');
+    return pieces
+        .map((p) => (p.type === 'text' ? p.value : p.type === 'tag' ? collectText(p.children) : p.type === 'plural' ? ` ${p.other} ` : ' '))
+        .join('');
 }
 function serialize(pieces) {
     let out = '';
@@ -475,7 +554,8 @@ function serialize(pieces) {
             out += `{${p.name}}`;
         }
         else if (p.type === 'plural') {
-            out += `{${p.name}, plural, one {# ${p.one}} other {# ${p.other}}}`;
+            const hash = p.hash === false ? '' : '# ';
+            out += `{${p.name}, plural, one {${hash}${p.one}} other {${hash}${p.other}}}`;
         }
         else {
             const inner = serialize(p.children);

package/dist/utils/key-usage.js

@@ -113,7 +113,7 @@ async function findKeyUsage(workspace) {
     const dynamicFiles = [];
     const seen = new Set();
     for (const dir of workspace.sourceDirs) {
-        const files = await (0, file_utils_1.findFiles)(path.join(workspace.path, dir), types_1.SUPPORTED_EXTENSIONS, types_1.EXCLUDED_PATTERNS);
+        const files = await (0, file_utils_1.findFiles)(path.join(workspace.path, dir), types_1.SUPPORTED_EXTENSIONS, (0, types_1.workspaceExcludes)(workspace));
         for (const file of files) {
             if (seen.has(file))
                 continue;

package/dist/utils/metadata.d.ts

@@ -33,7 +33,7 @@ export interface BabelizeConfig {
     excludePatterns: string[];
     customTranslations: Record<string, Record<string, string>>;
 }
-export type FrameworkType = 'react' | 'nextjs' | 'vue' | 'angular' | 'svelte' | 'astro' | 'remix' | 'gatsby' | 'nuxt' | 'static' | 'django' | 'unknown';
+export type FrameworkType = 'react' | 'nextjs' | 'vue' | 'angular' | 'svelte' | 'astro' | 'remix' | 'gatsby' | 'nuxt' | 'static' | 'django' | 'react-native' | 'unknown';
 export type PackageManagerType = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'pip' | 'poetry' | 'pipenv' | 'uv' | 'pdm';
 export interface ProjectInfo {
     framework: FrameworkType;
@@ -43,6 +43,8 @@ export interface ProjectInfo {
     packageManagers: PackageManagerType[];
     /** Set when the project is built with something Babelize doesn't support yet, e.g. "Laravel". */
     unsupportedFramework?: string;
+    /** The app's folder in a monorepo (`apps/mobile`); unset when the app is the repository root. */
+    appDir?: string;
     nodeVersion?: string;
     projectVersion?: string;
     projectName?: string;
@@ -57,6 +59,8 @@ export interface ProjectInfo {
         gatsby?: string;
         nuxt?: string;
         'react-i18next'?: string;
+        'react-native'?: string;
+        expo?: string;
     };
     detectedAt: string;
 }

package/dist/utils/metadata.js

@@ -56,6 +56,7 @@ const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 const logger_1 = require("./logger");
 const stack_1 = require("../detection/stack");
+const validate_1 = require("../modules/workspace/validate");
 const DEFAULT_CONFIG = {
     sourceLocale: 'en',
     targetLocales: [],
@@ -178,12 +179,26 @@ async function detectProjectInfo(workspacePath) {
             });
         }
     }
+    // A monorepo whose root has no framework: describe the app package
+    // (apps/mobile), the one runs translate.
+    let appDir;
+    const rootDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    if (!['next', 'expo', 'react-native', 'nuxt', 'vue', 'react', 'react-dom'].some((d) => rootDeps[d])) {
+        const app = await (0, validate_1.findWorkspaceApp)(workspacePath, packageJson).catch(() => null);
+        if (app) {
+            appDir = app.dir;
+            packageJson = app.packageJson;
+        }
+    }
     const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
     const frameworks = [];
     let primaryFramework = 'unknown';
     let frameworkVersion;
     const frameworkChecks = [
         { name: 'nextjs', dep: 'next' },
+        // Before react: every Expo / React Native app depends on react too.
+        { name: 'react-native', dep: 'expo' },
+        { name: 'react-native', dep: 'react-native' },
         { name: 'nuxt', dep: 'nuxt' },
         { name: 'gatsby', dep: 'gatsby' },
         { name: 'remix', dep: '@remix-run/react' },
@@ -194,7 +209,7 @@ async function detectProjectInfo(workspacePath) {
         { name: 'react', dep: 'react' },
     ];
     for (const check of frameworkChecks) {
-        if (deps[check.dep]) {
+        if (deps[check.dep] && !frameworks.includes(check.name)) {
             frameworks.push(check.name);
             if (primaryFramework === 'unknown') {
                 primaryFramework = check.name;
@@ -222,6 +237,7 @@ async function detectProjectInfo(workspacePath) {
     const primaryPackageManager = packageManagers.length > 0 ? packageManagers[0] : 'unknown';
     const projectInfo = {
         framework: primaryFramework,
+        ...(appDir ? { appDir } : {}),
         frameworks: frameworks.length > 0 ? frameworks : undefined,
         frameworkVersion,
         packageManager: primaryPackageManager,
@@ -240,6 +256,8 @@ async function detectProjectInfo(workspacePath) {
             gatsby: deps['gatsby'],
             nuxt: deps['nuxt'],
             'react-i18next': deps['react-i18next'],
+            'react-native': deps['react-native'],
+            expo: deps['expo'],
         },
         detectedAt: new Date().toISOString(),
     };

package/dist/utils/module-constants.d.ts

@@ -11,18 +11,36 @@ import * as t from '@babel/types';
  * There's no hook at module level, so the strings can't be replaced in
  * place. When every use of the copy is provably a render (a JSX child, a
  * translatable attribute, or a React `key`), the constant's strings become
- * translation keys and each render becomes `t(tab)`. Otherwise — the values
- * are also data (compared, sent, used in URLs) — nothing is rewritten and the
- * strings are reported, so a run doesn't claim everything was translated.
+ * translation keys and each render becomes `t(tab)`.
+ *
+ * When the values are also data (compared, sent, used in URLs), the constant
+ * stays as it is and only what's displayed is translated, through a map from
+ * value to key: `label={t(NICHES_KEYS[n] ?? n)}` while `selected === n` and
+ * the API keep the English value. Anything else that can't be wired safely
+ * (form data, a sentence, outside a component) is reported, so a run doesn't
+ * claim everything was translated.
  */
 export interface ModuleConstantPlan {
     name: string;
+    /** Where a value → key map goes: after the constant, or before the statement holding an inline list. */
+    anchor: NodePath<t.Statement>;
+    insert: 'after' | 'before';
     /** Every use of the copy is a render: safe to rewrite. */
     provable: boolean;
+    /** Rendered, and also used as data: keep the values, translate the renders through a value → key map. */
+    labels: boolean;
     /** The UI strings that are rendered (rewritten to keys when provable). */
     literals: Array<NodePath<t.StringLiteral>>;
+    /** Field of each literal: '' for an array of strings, the property name for objects. */
+    literalFields: string[];
     /** Expressions that render a string (`tab`, `item.label`), wrapped in `t()` when provable. */
     renderSites: Array<NodePath<t.Expression>>;
+    /** Field of each render site. */
+    renderFields: string[];
+    /** Value → key maps an earlier run added, by field: their renders are already wrapped. */
+    labelMaps: Map<string, string>;
+    /** Fields with values that aren't copy: those aren't in the map and are shown as they are. */
+    partialFields: Set<string>;
     /** Why it isn't provable, when it isn't. */
     reason?: string;
 }

package/dist/utils/module-constants.js

@@ -77,6 +77,47 @@ function inSentence(p) {
     }
     return false;
 }
+const MAP_NAME = /(?:_KEYS|Keys)\d*$/;
+/** `X_KEYS[v]` with X_KEYS a module const object Babelize named: the map's name. */
+function mapLookup(node, scope) {
+    if (!t.isMemberExpression(node) || !node.computed || !t.isIdentifier(node.object) || !MAP_NAME.test(node.object.name))
+        return null;
+    const binding = scope.getBinding(node.object.name);
+    if (!binding || binding.kind !== 'const' || !t.isVariableDeclarator(binding.path.node) || !t.isObjectExpression(binding.path.node.init))
+        return null;
+    return { map: node.object.name, value: node.property };
+}
+/**
+ * A render an earlier run wired through a value → key map, in either form it
+ * writes: `t(X_KEYS[v] ?? v)`, or `X_KEYS[v] ? t(X_KEYS[v]) : v` when some
+ * values aren't in the map. The map's name, or null.
+ */
+function labelSite(node, scope) {
+    const translatorCall = (n) => t.isCallExpression(n) && t.isIdentifier(n.callee) && n.arguments.length === 1 ? n.arguments[0] : null;
+    const arg = translatorCall(node);
+    if (arg && t.isLogicalExpression(arg) && arg.operator === '??') {
+        const lookup = mapLookup(arg.left, scope);
+        return lookup && t.isNodesEquivalent(lookup.value, arg.right) ? lookup.map : null;
+    }
+    if (t.isConditionalExpression(node)) {
+        const lookup = mapLookup(node.test, scope);
+        const inner = mapLookup(translatorCall(node.consequent), scope);
+        if (!lookup || !inner || inner.map !== lookup.map)
+            return null;
+        return t.isNodesEquivalent(lookup.value, inner.value) && t.isNodesEquivalent(lookup.value, node.alternate) ? lookup.map : null;
+    }
+    return null;
+}
+/** `expr` (the `v`, or `p.label`) is one of the uses inside such a render: the map's name. */
+function labelMapAt(expr) {
+    let cur = expr.parentPath;
+    for (let depth = 0; cur && depth < 4; depth++, cur = cur.parentPath) {
+        const map = labelSite(cur.node, cur.scope);
+        if (map)
+            return map;
+    }
+    return null;
+}
 function memberName(p) {
     if (!p.isMemberExpression() || p.node.computed || !t.isIdentifier(p.node.property))
         return null;
@@ -93,21 +134,58 @@ function analyzeModuleConstants(ast) {
                 if (!decl?.isVariableDeclaration() || decl.node.kind !== 'const')
                     continue;
                 for (const d of decl.get('declarations')) {
-                    const plan = planFor(d, exported);
+                    if (!t.isIdentifier(d.node.id))
+                        continue;
+                    const binding = d.scope.getBinding(d.node.id.name);
+                    if (!binding)
+                        continue;
+                    const plan = planFor({
+                        name: d.node.id.name,
+                        init: d.get('init'),
+                        references: binding.referencePaths,
+                        reassigned: binding.constantViolations.length > 0,
+                        exported,
+                        anchor: stmt,
+                        insert: 'after',
+                    });
                     if (plan)
                         plans.push(plan);
                 }
             }
-            program.stop();
+        },
+        // `{["Instagram", "Both"].map((p) => <Chip label={p} onPress={() => save(p)} />)}`: an
+        // inline list in a component. Shown only, its values are translated in place like any
+        // string; also used as data, it gets a map like a constant.
+        ArrayExpression(list) {
+            const member = list.parentPath;
+            if (!member?.isMemberExpression() || member.node.object !== list.node || memberName(member) !== 'map')
+                return;
+            if (!inComponent(list))
+                return;
+            const cb = member.parentPath.isCallExpression() ? member.parentPath.get('arguments')[0] : undefined;
+            const param = cb && (cb.isArrowFunctionExpression() || cb.isFunctionExpression()) ? cb.node.params[0] : undefined;
+            if (!t.isIdentifier(param))
+                return;
+            const anchor = list.find((p) => !!p.parentPath?.isProgram());
+            if (!anchor)
+                return;
+            const plan = planFor({
+                name: param.name.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase(),
+                init: list,
+                references: [list],
+                reassigned: false,
+                exported: false,
+                anchor,
+                insert: 'before',
+            });
+            // Shown only: the in-place translation handles it.
+            if (plan && !plan.provable)
+                plans.push(plan);
         },
     });
     return plans;
 }
-function planFor(d, exported) {
-    if (!t.isIdentifier(d.node.id))
-        return null;
-    const name = d.node.id.name;
-    const init = d.get('init');
+function planFor({ name, init, references, reassigned, exported, anchor, insert }) {
     const isCopy = (s) => (0, string_utils_1.isTranslatableText)(s.trim());
     // Per "field" ('' for an array of strings): the UI-copy literals that would
     // become keys, every translatable literal (reported if not provable), and
@@ -116,7 +194,10 @@ function planFor(d, exported) {
     // "FAQ"]` with only "Overview" keyed would render a missing key for FAQ.
     const byField = new Map();
     const translatable = new Map();
+    // A value that isn't a string literal (or is missing): renders can't be translated at all.
     const incomplete = new Set();
+    // A literal that isn't copy ("FMCG", "YouTube"): shown as it is, beside the translated ones.
+    const partial = new Map();
     const push = (map, field, lit) => map.set(field, [...(map.get(field) ?? []), lit]);
     const consider = (field, value, uiCopy) => {
         if (!value.isStringLiteral()) {
@@ -128,7 +209,7 @@ function planFor(d, exported) {
         if (isCopy(value.node.value) && uiCopy(value.node.value))
             push(byField, field, value);
         else
-            incomplete.add(field);
+            partial.set(field, [...(partial.get(field) ?? []), value.node.value]);
     };
     let kind;
     const objectFields = (objects) => {
@@ -181,14 +262,19 @@ function planFor(d, exported) {
     }
     if (translatable.size === 0)
         return null;
-    const binding = d.scope.getBinding(name);
-    if (!binding)
-        return null;
     const sites = new Map();
+    // What stops any rewrite, and uses as data (which only rule out rewriting the values).
     const fail = [];
+    const data = [];
+    const labelMaps = new Map();
     const site = (field, expr) => {
-        if (!translatable.has(field))
-            return; // nothing translatable rendered from it
+        if (!byField.has(field))
+            return; // no copy rendered from it
+        const mapped = labelMapAt(expr);
+        if (mapped) {
+            labelMaps.set(field, mapped);
+            return;
+        }
         const pos = positionOf(expr);
         if (pos === 'render') {
             if (!inComponent(expr))
@@ -197,6 +283,9 @@ function planFor(d, exported) {
                 fail.push('rendered inside a sentence');
             else if (incomplete.has(field))
                 fail.push('not every value is a translatable string');
+            // Values left as they are render through the map's `?? value`; i18next would read a `:` as a namespace.
+            else if (partial.has(field))
+                data.push('not every value is copy: those are shown as they are');
             sites.set(field, [...(sites.get(field) ?? []), expr]);
         }
         else if (pos === 'form') {
@@ -204,15 +293,16 @@ function planFor(d, exported) {
             fail.push(`${expr.toString()} is form data (<option> without a value, or <textarea>)`);
             sites.set(field, [...(sites.get(field) ?? []), expr]);
         }
-        else if (pos === 'other') {
-            fail.push(`${expr.toString()} is used as data`);
+        else if (pos === 'other' && byField.has(field)) {
+            // A field that isn't copy (`tab.id`, `p.icon`) is never rewritten: using it as data is fine.
+            data.push(`${expr.toString()} is used as data`);
         }
     };
     if (exported)
-        fail.push('exported');
-    if (binding.constantViolations.length)
+        data.push('exported');
+    if (reassigned)
         fail.push('reassigned');
-    for (const ref of binding.referencePaths) {
+    for (const ref of references) {
         const parent = ref.parentPath;
         const prop = memberName(parent);
         if ((kind === 'strings' || kind === 'objects') && prop === 'map' && parent.parentPath?.isCallExpression() && parent.parentPath.node.callee === parent.node) {
@@ -235,7 +325,7 @@ function planFor(d, exported) {
                 const member = use.parentPath;
                 const field = memberName(member);
                 if (field === null || !member.isMemberExpression() || member.node.object !== use.node) {
-                    fail.push(`${param.name} is used as a whole`);
+                    data.push(`${param.name} is used as a whole`);
                 }
                 else {
                     site(field, member);
@@ -252,14 +342,22 @@ function planFor(d, exported) {
             site('', parent);
             continue;
         }
-        fail.push(`${name} is used as data`);
+        data.push(`${name} is used as data`);
     }
-    if (sites.size === 0)
+    if (sites.size === 0 && labelMaps.size === 0)
         return null; // never rendered: it's data
-    const provable = fail.length === 0;
-    // Provable: the keyed literals (all values of each rendered field).
+    const provable = fail.length === 0 && data.length === 0 && labelMaps.size === 0;
+    const labels = fail.length === 0 && !provable;
+    // Rewritable: the keyed literals (all values of each rendered field).
     // Otherwise: every translatable literal that is rendered, to report.
-    const literals = [...sites.keys()].flatMap((f) => (provable ? byField : translatable).get(f) ?? []);
+    const fields = [...new Set([...sites.keys(), ...labelMaps.keys()])];
+    const literalFields = [];
+    const literals = fields.flatMap((f) => {
+        const lits = (provable || labels ? byField : translatable).get(f) ?? [];
+        literalFields.push(...lits.map(() => f));
+        return lits;
+    });
+    const renderFields = [...sites].flatMap(([f, list]) => list.map(() => f));
     const renderSites = [...sites.values()].flat();
-    return { name, provable, literals, renderSites, reason: fail[0] };
+    return { name, anchor, insert, provable, labels, literals, literalFields, renderSites, renderFields, labelMaps, partialFields: new Set(partial.keys()), reason: fail[0] ?? data[0] };
 }

package/dist/utils/react-native.d.ts

@@ -0,0 +1,17 @@
+import * as t from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+/**
+ * `options={{ title: 'Home' }}`, `screenOptions={{ headerTitle: 'Settings' }}`,
+ * `options={({ route }) => ({ tabBarLabel: 'Feed' })}`: the literal is the
+ * value of a title key inside an options / screenOptions attribute.
+ */
+export declare function isNavigationTitle(path: NodePath): boolean;
+/** `Alert.alert(…)` / `Alert.prompt(…)` from react-native. */
+export declare function isAlertCall(callee: t.Node): boolean;
+/** The title or message argument of an Alert call (button labels are `text:` properties). */
+export declare function isAlertTextArgument(path: NodePath): boolean;
+/**
+ * A two-letter word that is still UI copy in a string literal: "OK", "No",
+ * "Go". Literals shorter than three characters are otherwise dropped as noise.
+ */
+export declare function isShortUiWord(text: string): boolean;