@babelize/engine 0.1.2 → 0.2.0

package/dist/utils/ast-helpers.js

@@ -37,12 +37,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.traverse = exports.t = exports.generate = void 0;
+exports.sourceOffset = sourceOffset;
 exports.parseCode = parseCode;
 exports.generateCode = generateCode;
 exports.placeStatementsOnOwnLines = placeStatementsOnOwnLines;
 exports.isJSXText = isJSXText;
 exports.isAlreadyTranslated = isAlreadyTranslated;
 exports.isNonTranslatableContext = isNonTranslatableContext;
+exports.isValuePassthrough = isValuePassthrough;
 exports.getComponentName = getComponentName;
 exports.isInsideComponent = isInsideComponent;
 exports.findComponentBody = findComponentBody;
@@ -57,6 +59,7 @@ exports.getParentContext = getParentContext;
 exports.extractExpressionContent = extractExpressionContent;
 exports.extractConditionalContent = extractConditionalContent;
 exports.hasUseClientDirective = hasUseClientDirective;
+exports.bindsTopLevel = bindsTopLevel;
 const generator_1 = __importDefault(require("@babel/generator"));
 exports.generate = generator_1.default;
 const parser = __importStar(require("@babel/parser"));
@@ -64,7 +67,80 @@ const traverse_1 = __importDefault(require("@babel/traverse"));
 exports.traverse = traverse_1.default;
 const t = __importStar(require("@babel/types"));
 exports.t = t;
+const recast = __importStar(require("recast"));
+const jsx_message_1 = require("./jsx-message");
+/** ASTs parsed with `preserveFormat`, which `generateCode` prints with recast. */
+const formatPreserving = new WeakMap();
+const LINE_BREAK = /\r\n|\r(?!\n)|\n|\u2028|\u2029/g;
+/** The file's own layout, which recast keeps when it prints new code. */
+function layoutOf(code) {
+    const tabIndented = (code.match(/^\t/gm)?.length ?? 0) > (code.match(/^ {2}/gm)?.length ?? 0);
+    const unit = code.match(/^( {2,})\S/m)?.[1].length ?? 2;
+    return {
+        lineTerminator: code.includes('\r\n') ? '\r\n' : '\n',
+        tabWidth: tabIndented ? 2 : Math.min(unit, 4),
+        useTabs: tabIndented,
+    };
+}
+/** Columns a line's leading whitespace takes in recast's copy of the source (its `countSpaces`). */
+function indentColumns(spaces, tabWidth) {
+    let count = 0;
+    for (const ch of spaces) {
+        if (ch === '\t') {
+            const next = Math.ceil(count / tabWidth) * tabWidth;
+            count = next === count ? count + tabWidth : next;
+        }
+        else if (!'\v\f\r'.includes(ch)) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Where a node starts in the file as written. Recast hands the parser a
+ * normalized copy (`\n` line endings, leading tabs expanded), so the node's
+ * own offset can differ from the source offsets extraction recorded.
+ */
+function sourceOffset(ast, node) {
+    const preserved = formatPreserving.get(ast);
+    if (!preserved || !node.loc)
+        return node.start ?? undefined;
+    const { line, column } = node.loc.start;
+    const text = preserved.lines[line - 1];
+    if (text === undefined)
+        return undefined;
+    const lead = /^\s*/.exec(text)[0];
+    const indent = indentColumns(lead, preserved.layout.tabWidth ?? 4);
+    return preserved.lineStarts[line - 1] + (column >= indent ? lead.length + (column - indent) : column);
+}
 function parseCode(code, options = {}) {
+    if (options.preserveFormat) {
+        try {
+            // One line ending throughout (recast prints one), no exotic terminators.
+            const crlf = code.split('\r\n').length - 1;
+            if (crlf > 0 && crlf !== code.split('\n').length - 1)
+                throw new Error('mixed line endings');
+            if (/\r(?!\n)|[\u2028\u2029]/.test(code))
+                throw new Error('unusual line terminators');
+            const layout = layoutOf(code);
+            const ast = recast.parse(code, {
+                ...layout,
+                parser: { parse: (source) => babelParse(source, { ...options, tokens: true }) },
+            });
+            const lines = code.split(LINE_BREAK);
+            const lineStarts = [0];
+            for (const m of code.matchAll(LINE_BREAK))
+                lineStarts.push(m.index + m[0].length);
+            formatPreserving.set(ast, { layout, source: code, lines, lineStarts });
+            return ast;
+        }
+        catch {
+            // Syntax recast can't track: fall back to reprinting the whole file.
+        }
+    }
+    return babelParse(code, options);
+}
+function babelParse(code, options) {
     const { sourceType = 'module', isTypeScript = options.filename ? !/\.jsx?$/i.test(options.filename) : true, isJSX = true } = options;
     const plugins = [];
     if (isJSX)
@@ -76,9 +152,19 @@ function parseCode(code, options = {}) {
         sourceType,
         plugins,
         errorRecovery: true,
+        tokens: options.tokens,
     });
 }
 function generateCode(ast, originalCode) {
+    const preserved = formatPreserving.get(ast);
+    if (preserved) {
+        try {
+            return printPreservingFormat(ast, preserved.layout, preserved.source);
+        }
+        catch {
+            // Fall through to a full reprint.
+        }
+    }
     const result = (0, generator_1.default)(ast, {
         retainLines: true,
         retainFunctionParens: true,
@@ -98,6 +184,169 @@ function generateCode(ast, originalCode) {
     }
     return code;
 }
+const SNIPPET_PARSER = {
+    parser: { parse: (source) => babelParse(source, { tokens: true }) },
+};
+/**
+ * One line of Babel output for a node the engine added, or null when it holds
+ * original code that spans lines (a component body wrapped in a block): that
+ * is left to recast, which keeps the original part as written.
+ */
+function oneLineCode(node) {
+    let multiLine = false;
+    t.traverseFast(node, (n) => {
+        if (n.loc && n.loc.start.line !== n.loc.end.line)
+            multiLine = true;
+    });
+    if (multiLine)
+        return null;
+    // Without locations, retainLines prints everything on one line.
+    let code;
+    try {
+        code = (0, generator_1.default)(t.cloneNode(node, true, true), { comments: false, retainLines: true, jsescOption: { minimal: true } }).code.trim();
+    }
+    catch {
+        return null; // a node Babel can't print on its own: recast prints it
+    }
+    return code.includes('\n') ? null : code;
+}
+/**
+ * Recast prints an added expression with its own printer, which puts every
+ * object on several lines (`t("k", {\n  total\n})`). Instead, print it with
+ * Babel and swap in that node parsed from its own text: recast reuses a
+ * parsed node's source as it is. Statements and blocks stay with recast,
+ * which spaces them within the surrounding code.
+ */
+function snippetNode(node, parent) {
+    if (t.isStatement(node) || t.isProgram(node) || t.isFunction(node))
+        return null;
+    // A name (it may carry a type annotation) or a pattern prints fine as it is.
+    if (t.isIdentifier(node) || t.isPattern(node))
+        return null;
+    // A declared object (a map of labels) reads better one entry per line.
+    if (t.isObjectExpression(node) && t.isVariableDeclarator(parent))
+        return null;
+    const swappable = t.isExpression(node) || t.isJSXExpressionContainer(node) || t.isJSXText(node) || t.isJSXAttribute(node) || t.isObjectProperty(node);
+    if (!swappable)
+        return null;
+    const code = oneLineCode(node);
+    if (code === null)
+        return null;
+    const parse = (source) => recast.parse(source, SNIPPET_PARSER).program.body;
+    const init = (source) => {
+        const decl = parse(source)[0];
+        return t.isVariableDeclaration(decl) ? decl.declarations[0].init : null;
+    };
+    if (t.isExpression(node))
+        return init(`const __babelize = ${code};`) ?? null;
+    if (t.isJSXExpressionContainer(node) || t.isJSXText(node)) {
+        const fragment = init(`const __babelize = <>${code}</>;`);
+        return t.isJSXFragment(fragment) && fragment.children.length === 1 ? fragment.children[0] : null;
+    }
+    if (t.isJSXAttribute(node)) {
+        const el = init(`const __babelize = <x ${code} />;`);
+        return t.isJSXElement(el) ? (el.openingElement.attributes[0] ?? null) : null;
+    }
+    if (t.isObjectProperty(node)) {
+        const obj = init(`const __babelize = { ${code} };`);
+        return t.isObjectExpression(obj) ? (obj.properties[0] ?? null) : null;
+    }
+    return null;
+}
+/** A node recast didn't parse from this file's source: the engine added (or cloned) it. */
+function isAdded(node) {
+    return !node.original;
+}
+const escapeRegex = (x) => x.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+function printPreservingFormat(ast, layout, source) {
+    // Added statements recast may print across lines (`const {\n  t\n} = …`), as one line each.
+    const statements = new Set();
+    (0, traverse_1.default)(ast, {
+        enter(path) {
+            if (!isAdded(path.node) || path.isProgram() || path.isFile())
+                return;
+            if (path.isStatement() && !path.isBlockStatement()) {
+                // Short ones (a hook, an import); a long one, like a map of labels, reads better across lines.
+                const declaresObject = path.isVariableDeclaration() && path.node.declarations.some((d) => t.isObjectExpression(d.init));
+                const code = declaresObject ? null : oneLineCode(path.node);
+                if (code && code.length <= 100)
+                    statements.add(code);
+            }
+            // Comments the engine attached stay with recast's printer.
+            if (path.node.leadingComments?.length || path.node.trailingComments?.length)
+                return;
+            const replacement = snippetNode(path.node, path.parent);
+            if (!replacement)
+                return; // recast prints it; the added nodes inside get their turn
+            // Not replaceWith: it copies comment arrays onto the node, and recast then
+            // sees it as changed and reprints it (wrapping at 74 columns).
+            // Recast reuses the snippet's text through `.original`; without locations
+            // of their own, the swapped-in nodes are also safe for the Babel fallback.
+            t.traverseFast(replacement, (n) => {
+                n.loc = null;
+            });
+            if (Array.isArray(path.container))
+                path.container[path.key] = replacement;
+            else
+                path.parent[path.key] = replacement;
+            path.skip();
+        },
+    });
+    let code = recast.print(ast, { ...layout, quote: 'double' }).code;
+    // Recast reprints a directive whose program body changed with a second `;`.
+    const directive = /^([ \t]*(['"])use [\w ]+\2);;/gm;
+    if (!directive.test(source))
+        code = code.replace(directive, '$1;');
+    for (const statement of statements) {
+        const tokens = statement.match(/[A-Za-z_$][\w$]*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S/g) ?? [];
+        if (tokens.length === 0)
+            continue;
+        // Recast follows a statement it printed across lines with a blank line; that goes too.
+        const re = new RegExp(`${tokens.map(escapeRegex).join('\\s*')}(\\r?\\n[ \\t]*(?=\\r?\\n))?`, 'g');
+        code = code.replace(re, (match, blank) => {
+            const printed = blank === undefined ? match : match.slice(0, -blank.length);
+            // Only what recast printed for the added statement: the same code the user wrote stays theirs.
+            if (!printed.includes('\n') || source.includes(printed))
+                return match;
+            return statement;
+        });
+        // An added import is followed by a blank line when code, not another import, comes next.
+        if (statement.startsWith('import ')) {
+            const importLine = new RegExp(`^(${escapeRegex(statement)})(\\r?\\n)(?!\\r?\\n|import\\b)`, 'm');
+            code = code.replace(importLine, '$1$2$2');
+        }
+    }
+    // Recast indents the lines it adds with spaces even with useTabs; give them the file's tabs.
+    if (layout.useTabs)
+        code = tabsOnAddedLines(code, layout, source);
+    return code;
+}
+/** Space indentation → tabs on lines recast added, never inside a template literal (that's the string's content). */
+function tabsOnAddedLines(code, layout, source) {
+    const eol = layout.lineTerminator ?? '\n';
+    const originalLines = new Set(source.split(eol));
+    const lines = code.split(eol);
+    if (lines.every((line) => originalLines.has(line) || !/^ /.test(line)))
+        return code;
+    const inTemplate = new Set();
+    try {
+        (0, traverse_1.default)(babelParse(code, {}), {
+            TemplateElement(p) {
+                const loc = p.node.loc;
+                if (loc)
+                    for (let l = loc.start.line + 1; l <= loc.end.line; l++)
+                        inTemplate.add(l);
+            },
+        });
+    }
+    catch {
+        return code; // can't tell where literals are: leave the indentation as printed
+    }
+    const width = layout.tabWidth ?? 2;
+    return lines
+        .map((line, i) => originalLines.has(line) || inTemplate.has(i + 1) ? line : line.replace(/^ +/, (spaces) => '\t'.repeat(Math.ceil(spaces.length / width))))
+        .join(eol);
+}
 /**
  * With `retainLines`, statements the injector adds (which have no source
  * location) are printed on the line of the preceding token, e.g.
@@ -178,6 +427,9 @@ function isNonTranslatableContext(path) {
     let current = path;
     let isInFunctionOrClass = false;
     let hasFunctionOrClassBetween = false;
+    // The expression that would be a computed key: the literal itself, or the
+    // ternary / logical expression it is a branch of.
+    let keyCandidate = path.node;
     while (current) {
         if (current.isFunction() || current.isClass()) {
             isInFunctionOrClass = true;
@@ -227,7 +479,9 @@ function isNonTranslatableContext(path) {
                 return true;
             }
         }
-        if (current.isMemberExpression() && current.node.computed && current.node.property === path.node) {
+        // An object key, also when picked by a ternary or fallback:
+        // `Colors[scheme === 'unspecified' ? 'light' : scheme]`, `map[key ?? 'default']`.
+        if (current.isMemberExpression() && current.node.computed && current.node.property === keyCandidate) {
             return true;
         }
         if (current.isSwitchCase() && current.node.test === path.node) {
@@ -272,10 +526,25 @@ function isNonTranslatableContext(path) {
                     return true;
             }
         }
-        current = current.parentPath;
+        const parent = current.parentPath;
+        if (parent && keyCandidate === current.node && isValuePassthrough(parent.node, current.node)) {
+            keyCandidate = parent.node;
+        }
+        current = parent;
     }
     return false;
 }
+/**
+ * Expressions a value passes through unchanged on its way to its slot:
+ * `a ? 'x' : b`, `k ?? 'x'`, `('x' as K)`, `x!`.
+ */
+function isValuePassthrough(node, child) {
+    if (t.isConditionalExpression(node))
+        return node.consequent === child || node.alternate === child;
+    if (t.isLogicalExpression(node))
+        return node.left === child || node.right === child;
+    return t.isTSAsExpression(node) || t.isTSSatisfiesExpression(node) || t.isTSNonNullExpression(node) || t.isParenthesizedExpression(node);
+}
 function getComponentName(path) {
     if (path.isVariableDeclarator()) {
         if (t.isIdentifier(path.node.id))
@@ -390,11 +659,16 @@ function returnsJsx(fn) {
     return found;
 }
 /**
- * Whether `fn` is a component the hook can go in: not a callback passed to
- * another call (`items.map((x) => …)`, except memo/forwardRef), and either
- * PascalCase-named, the default export, or returning JSX itself.
+ * Whether `fn` is a component (or custom hook) the hook can go in: not a
+ * callback passed to another call (`items.map((x) => …)`, except
+ * memo/forwardRef), and PascalCase-named, `use*`-named, the default export,
+ * or an unnamed function returning JSX. A lowercase function that returns JSX
+ * (`function renderHint() { return <Text>…</Text> }`) is a helper: a hook in
+ * it breaks the rules of hooks (and `react-hooks/rules-of-hooks` fails the
+ * user's lint), so its strings belong to the enclosing component, or to the
+ * module-level `t` when there is none.
  */
-function isComponentFunction(fn) {
+function isComponentFunction(fn, renderHelpers = false) {
     const parent = fn.parentPath;
     if (parent?.isCallExpression() && parent.node.arguments.includes(fn.node) && !isComponentWrapperCall(parent))
         return false;
@@ -412,8 +686,8 @@ function isComponentFunction(fn) {
     }
     if (parent?.isExportDefaultDeclaration())
         return true;
-    if (name && /^[A-Z]/.test(name))
-        return true;
+    if (name)
+        return /^[A-Z]/.test(name) || /^use[A-Z0-9]/.test(name) || (renderHelpers && returnsJsx(fn));
     return returnsJsx(fn);
 }
 /**
@@ -421,14 +695,16 @@ function isComponentFunction(fn) {
  * goes. Skips callbacks (a hook inside `.map(…)` breaks the rules of hooks);
  * null when there's no component with a block body.
  */
-function findComponentBody(path) {
+function findComponentBody(path, 
+/** Also lowercase functions returning JSX (render helpers), for when there is no module-level t. */
+options = {}) {
     let current = path;
     while (current) {
         if (current.isArrowFunctionExpression() ||
             current.isFunctionExpression() ||
             current.isFunctionDeclaration()) {
             const body = current.get('body');
-            if (!Array.isArray(body) && body.isBlockStatement() && isComponentFunction(current))
+            if (!Array.isArray(body) && body.isBlockStatement() && isComponentFunction(current, options.renderHelpers))
                 return body;
         }
         current = current.parentPath;
@@ -527,25 +803,50 @@ function getParentContext(path) {
         siblingGroupId: Math.abs(hash).toString(36),
     };
 }
-function extractExpressionContent(node, variables = []) {
+/**
+ * A string-building expression as one message: `\`Hi ${user.name}\`` and
+ * `'Hi ' + name` → "Hi {name}". `variables` receives the placeholder names
+ * and, when given, `expressions` the expression behind each one (same order),
+ * so injection can rebuild the message as `t(key, { name: user.name })`.
+ */
+function extractExpressionContent(node, variables = [], expressions = []) {
     if (t.isStringLiteral(node))
         return node.value;
     if (t.isTemplateLiteral(node)) {
         let result = '';
         const quasis = node.quasis;
-        const expressions = node.expressions;
+        const exprs = node.expressions;
+        const nameOf = (expr) => t.isIdentifier(expr) ? expr.name
+            : t.isMemberExpression(expr) && t.isIdentifier(expr.property) ? expr.property.name
+                : `var${variables.length}`;
         for (let i = 0; i < quasis.length; i++) {
-            result += quasis[i].value.raw;
-            if (i < expressions.length) {
-                const expr = expressions[i];
-                let varName = `var${variables.length}`;
-                if (t.isIdentifier(expr)) {
-                    varName = expr.name;
-                }
-                else if (t.isMemberExpression(expr) && t.isIdentifier(expr.property)) {
-                    varName = expr.property.name;
+            // The text as it runs (`\n` is a line break), not as it's escaped in the source.
+            result += quasis[i].value.cooked ?? quasis[i].value.raw;
+            if (i < exprs.length) {
+                const expr = exprs[i];
+                // `${n} item${n === 1 ? '' : 's'}` → `{n, plural, one {# item} other {# items}}`.
+                const suffix = (0, jsx_message_1.pluralSuffix)(expr);
+                const word = suffix ? /([A-Za-z]+)$/.exec(result) : null;
+                if (suffix && word) {
+                    const at = variables.findIndex((_, j) => t.isNodesEquivalent(expressions[j], suffix.count));
+                    // A new count gets a name of its own: `${user.count} item${count === 1 …}` has two counts.
+                    let name = at >= 0 ? variables[at] : nameOf(suffix.count);
+                    for (let n = 2; at < 0 && variables.includes(name); n++)
+                        name = `${nameOf(suffix.count)}${n}`;
+                    if (at < 0) {
+                        variables.push(name);
+                        expressions.push(suffix.count);
+                    }
+                    const before = result.slice(0, -word[1].length);
+                    const counted = before.endsWith(`{${name}} `);
+                    const hash = counted ? '# ' : '';
+                    result = (counted ? before.slice(0, -`{${name}} `.length) : before)
+                        + `{${name}, plural, one {${hash}${word[1]}${suffix.one}} other {${hash}${word[1]}${suffix.other}}}`;
+                    continue;
                 }
+                const varName = nameOf(expr);
                 variables.push(varName);
+                expressions.push(expr);
                 result += `{${varName}}`;
             }
         }
@@ -554,36 +855,35 @@ function extractExpressionContent(node, variables = []) {
     if (t.isBinaryExpression(node) && node.operator === '+') {
         const leftVars = [];
         const rightVars = [];
-        const left = extractExpressionContent(node.left, leftVars);
-        const right = extractExpressionContent(node.right, rightVars);
+        const leftExprs = [];
+        const rightExprs = [];
+        const left = extractExpressionContent(node.left, leftVars, leftExprs);
+        const right = extractExpressionContent(node.right, rightVars, rightExprs);
+        const operandName = (operand) => t.isIdentifier(operand) ? operand.name
+            : t.isMemberExpression(operand) && t.isIdentifier(operand.property) ? operand.property.name
+                : null;
         if (left !== null && right !== null) {
             variables.push(...leftVars, ...rightVars);
+            expressions.push(...leftExprs, ...rightExprs);
             return left + right;
         }
-        if (left !== null && t.isIdentifier(node.right)) {
-            const varName = node.right.name;
-            variables.push(...leftVars, varName);
-            return left + `{${varName}}`;
+        // Identifiers before member expressions, as before: `'Hi ' + name`, `'Hi ' + user.name`.
+        const rightName = left !== null ? operandName(node.right) : null;
+        if (left !== null && rightName !== null) {
+            variables.push(...leftVars, rightName);
+            expressions.push(...leftExprs, node.right);
+            return left + `{${rightName}}`;
         }
-        if (right !== null && t.isIdentifier(node.left)) {
-            const varName = node.left.name;
-            variables.push(varName, ...rightVars);
-            return `{${varName}}` + right;
-        }
-        if (left !== null && t.isMemberExpression(node.right) && t.isIdentifier(node.right.property)) {
-            const varName = node.right.property.name;
-            variables.push(...leftVars, varName);
-            return left + `{${varName}}`;
-        }
-        if (right !== null && t.isMemberExpression(node.left) && t.isIdentifier(node.left.property)) {
-            const varName = node.left.property.name;
-            variables.push(varName, ...rightVars);
-            return `{${varName}}` + right;
+        const leftName = right !== null ? operandName(node.left) : null;
+        if (right !== null && leftName !== null) {
+            variables.push(leftName, ...rightVars);
+            expressions.push(node.left, ...rightExprs);
+            return `{${leftName}}` + right;
         }
         return null;
     }
     if (t.isJSXExpressionContainer(node)) {
-        return extractExpressionContent(node.expression, variables);
+        return extractExpressionContent(node.expression, variables, expressions);
     }
     return null;
 }
@@ -606,3 +906,16 @@ function hasUseClientDirective(ast) {
     }
     return false;
 }
+/** A top-level import or declaration already binds `name` (e.g. `t` from an earlier run's `@/i18n` import). */
+function bindsTopLevel(ast, name) {
+    for (const node of ast.program.body) {
+        if (t.isImportDeclaration(node) && node.specifiers.some((sp) => sp.local.name === name))
+            return true;
+        const decl = t.isExportNamedDeclaration(node) ? node.declaration : node;
+        if (t.isVariableDeclaration(decl) && decl.declarations.some((d) => t.isIdentifier(d.id, { name })))
+            return true;
+        if ((t.isFunctionDeclaration(decl) || t.isClassDeclaration(decl)) && decl.id?.name === name)
+            return true;
+    }
+    return false;
+}

package/dist/utils/extraction-options.js

@@ -19,7 +19,7 @@ async function resolveIcuOptions(workspace, llm) {
         return { sentences: false, plurals: true, icuRuntime: false, targetPlurals: false };
     }
     const deps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };
-    const strategy = ['react', 'nextjs'].includes(workspace.framework) ? StrategyFactory_1.StrategyFactory.getStrategy(workspace.framework, deps).id : 'other';
+    const strategy = ['react', 'nextjs', 'react-native'].includes(workspace.framework) ? StrategyFactory_1.StrategyFactory.getStrategy(workspace.framework, deps).id : 'other';
     let icuRuntime = false;
     let sentences = true;
     if (strategy === 'next-intl') {

package/dist/utils/file-utils.js

@@ -130,9 +130,12 @@ async function findFilesUncached(dir, extensions, excludePatterns = []) {
                 }
                 // Whole path segments only: a substring match excluded files like
                 // `components/Calibrate.tsx` ("lib") or `app/distance/page.tsx` ("dist").
+                // A leading `/` anchors to the walk root (`/ios` is the native
+                // project, not `src/screens/ios`).
                 if (pattern.includes('/')) {
                     const rel = relativePath.split(path.sep).join('/');
-                    return rel === pattern || rel.startsWith(`${pattern}/`);
+                    const anchored = pattern.startsWith('/') ? pattern.slice(1) : pattern;
+                    return rel === anchored || rel.startsWith(`${anchored}/`);
                 }
                 if (entry.name !== pattern)
                     return false;

package/dist/utils/i18n-config-path.d.ts

@@ -0,0 +1,18 @@
+import type { WorkspaceInfo } from '../runtime/types';
+type ConfigLocation = Pick<WorkspaceInfo, 'framework' | 'sourceDirs' | 'publicDir'>;
+/**
+ * The directory (workspace-relative) holding Babelize's generated i18next
+ * config, `i18n.ts`/`i18n.js`. Web: the source directory (`src`). React
+ * Native: next to the bundled locales, `src/` or the project root — never
+ * Expo Router's `app/`, where every file is a route.
+ */
+export declare function i18nConfigDir(workspace: ConfigLocation): string;
+/** The config's module path without extension, workspace-relative and '/'-separated (`src/i18n`, `i18n`). */
+export declare function i18nConfigModule(workspace: ConfigLocation): string;
+/**
+ * Import specifier for the generated config from `fromFile` (workspace-relative):
+ * `./i18n`, `../i18n`, `../../src/i18n`. Relative, because Metro and plain
+ * Vite/CRA projects have no `@/` alias.
+ */
+export declare function i18nImportPath(workspace: ConfigLocation, fromFile: string): string;
+export {};

package/dist/utils/i18n-config-path.js

@@ -0,0 +1,64 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18nConfigDir = i18nConfigDir;
+exports.i18nConfigModule = i18nConfigModule;
+exports.i18nImportPath = i18nImportPath;
+const path = __importStar(require("path"));
+/**
+ * The directory (workspace-relative) holding Babelize's generated i18next
+ * config, `i18n.ts`/`i18n.js`. Web: the source directory (`src`). React
+ * Native: next to the bundled locales, `src/` or the project root — never
+ * Expo Router's `app/`, where every file is a route.
+ */
+function i18nConfigDir(workspace) {
+    if (workspace.framework === 'react-native')
+        return workspace.publicDir || '.';
+    return workspace.sourceDirs.find((d) => d.includes('src')) || workspace.sourceDirs[0] || '.';
+}
+/** The config's module path without extension, workspace-relative and '/'-separated (`src/i18n`, `i18n`). */
+function i18nConfigModule(workspace) {
+    return path.posix.join(i18nConfigDir(workspace).split(path.sep).join('/'), 'i18n');
+}
+/**
+ * Import specifier for the generated config from `fromFile` (workspace-relative):
+ * `./i18n`, `../i18n`, `../../src/i18n`. Relative, because Metro and plain
+ * Vite/CRA projects have no `@/` alias.
+ */
+function i18nImportPath(workspace, fromFile) {
+    const from = path.posix.dirname(fromFile.split(path.sep).join('/'));
+    const rel = path.posix.relative(from, i18nConfigModule(workspace));
+    return rel.startsWith('.') ? rel : `./${rel}`;
+}

package/dist/utils/i18next-icu.js

@@ -96,7 +96,7 @@ async function detectI18nextIcu(workspace) {
     for (const dir of new Set(['.', ...workspace.sourceDirs])) {
         let files = [];
         try {
-            files = (await (0, file_utils_1.findFiles)(path.join(workspace.path, dir), types_1.SUPPORTED_EXTENSIONS, CONFIG_SCAN_EXCLUDES)) ?? [];
+            files = (await (0, file_utils_1.findFiles)(path.join(workspace.path, dir), types_1.SUPPORTED_EXTENSIONS, [...CONFIG_SCAN_EXCLUDES, ...(workspace.excludedPatterns ?? [])])) ?? [];
         }
         catch {
             files = [];

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

@@ -38,8 +38,8 @@ export interface IcuIssue {
 /**
  * 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.
  */
 export declare function compareIcuMessages(source: string, translated: string, targetLocale: string, options?: {
     /**