gt 2.11.3 → 2.12.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # gtx-cli
 
+## 2.12.0
+
+### Minor Changes
+
+- [#1137](https://github.com/generaltranslation/gt/pull/1137) [`f8993aa`](https://github.com/generaltranslation/gt/commit/f8993aabe07acdfaf8a97177f038c408a8fc4c45) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: object derivation
+
+### Patch Changes
+
+- Updated dependencies [[`f8993aa`](https://github.com/generaltranslation/gt/commit/f8993aabe07acdfaf8a97177f038c408a8fc4c45)]:
+  - @generaltranslation/python-extractor@0.2.0
+
 ## 2.11.3
 
 ### Patch Changes

package/dist/console/index.d.ts

@@ -21,7 +21,12 @@ export declare const warnInvalidDeriveInitSync: (file: string, functionName: str
 export declare const warnDataAttrOnBranch: (file: string, attrName: string, location?: string) => string;
 export declare const warnRecursiveFunctionCallSync: (file: string, functionName: string, location?: string) => string;
 export declare const warnDeriveFunctionNotWrappedSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnDeriveNonConstVariableSync: (file: string, varName: string, kind: string, location?: string) => string;
 export declare const warnDeriveFunctionNoResultsSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnDeriveUnresolvableValueSync: (file: string, key: string, location?: string) => string;
+export declare const warnDeriveCircularSpreadSync: (file: string, varName: string, location?: string) => string;
+export declare const warnDeriveDestructuringSync: (file: string, varName: string, location?: string) => string;
+export declare const warnDeriveOptionalChainingSync: (file: string, code: string, location?: string) => string;
 export declare const noLocalesError = "No locales found! Provide a list of locales for translation, or specify them in your gt.config.json file.";
 export declare const noDefaultLocaleError = "No default locale found! Provide a default locale, or specify it in your gt.config.json file.";
 export declare const noFilesError = "Incorrect or missing files configuration! Make sure your files are configured correctly in your gt.config.json file.";

package/dist/console/index.js

@@ -32,7 +32,12 @@ Invalid: ${colorizeContent(`const ${colorizeFunctionName(functionName)} = [() =>
 export const warnDataAttrOnBranch = (file, attrName, location) => withLocation(file, `${colorizeComponent(`<${BRANCH_COMPONENT}>`)} component ignores attributes prefixed with ${colorizeIdString('"data-"')}. Found ${colorizeIdString(attrName)}. Remove it or use a different attribute name.`, location);
 export const warnRecursiveFunctionCallSync = (file, functionName, location) => withLocation(file, withDeriveComponentError(`Recursive function call detected: ${colorizeFunctionName(functionName)}. A derivable (statically analyzable) function cannot use recursive calls to construct its result.`), location);
 export const warnDeriveFunctionNotWrappedSync = (file, functionName, location) => withLocation(file, withDeriveFunctionError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. This call is not wrapped in derive() (formerly declareStatic()). Ensure the function is properly wrapped with derive() and does not have circular import dependencies.`), location);
+export const warnDeriveNonConstVariableSync = (file, varName, kind, location) => withLocation(file, withDeriveFunctionError(`Variable ${colorizeFunctionName(varName)} is declared with '${kind}' but only 'const' declarations can be resolved statically. Change it to 'const'.`), location);
 export const warnDeriveFunctionNoResultsSync = (file, functionName, location) => withLocation(file, withDeriveFunctionError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. derive() (formerly declareStatic()) can only receive function invocations and cannot use undefined values or looped calls to construct its result.`), location);
+export const warnDeriveUnresolvableValueSync = (file, key, location) => withLocation(file, withDeriveFunctionError(`Object property ${colorizeFunctionName(formatCodeClamp(key))} could not be resolved to a static string value. Only string literals, template literals, conditionals, and function calls returning strings are supported.`), location);
+export const warnDeriveCircularSpreadSync = (file, varName, location) => withLocation(file, withDeriveFunctionError(`Circular spread detected involving ${colorizeFunctionName(varName)}. Spread references that form a cycle cannot be resolved statically.`), location);
+export const warnDeriveDestructuringSync = (file, varName, location) => withLocation(file, withDeriveFunctionError(`Variable ${colorizeFunctionName(varName)} uses destructuring syntax, which is not yet supported in derive(). Assign the value to a const variable directly instead.`), location);
+export const warnDeriveOptionalChainingSync = (file, code, location) => withLocation(file, withDeriveFunctionError(`Optional chaining (${colorizeFunctionName(formatCodeClamp(code))}) is not supported in derive(). Optional chaining implies the value could be undefined, which cannot be resolved statically. Use a non-optional access instead.`), location);
 // Re-export error messages
 export const noLocalesError = `No locales found! Provide a list of locales for translation, or specify them in your gt.config.json file.`;
 export const noDefaultLocaleError = `No default locale found! Provide a default locale, or specify it in your gt.config.json file.`;

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.11.3";
+export declare const PACKAGE_VERSION = "2.12.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const PACKAGE_VERSION = '2.11.3';
+export const PACKAGE_VERSION = '2.12.0';

package/dist/react/jsx/utils/parseString.d.ts

@@ -17,7 +17,7 @@ import { StringNode } from './types.js';
  * @param warnings - Set to collect warning messages
  * @returns Node | null
  */
-export declare function parseStringExpression(node: t.Node, tPath: NodePath, file: string, parsingOptions: ParsingConfigOptions, warnings?: Set<string>): StringNode | null;
+export declare function parseStringExpression(node: t.Node, tPath: NodePath, file: string, parsingOptions: ParsingConfigOptions, warnings: Set<string>, errors: string[]): StringNode | null;
 /**
  * Converts a Node tree to an array of all possible string combinations
  * This is a helper function for compatibility with existing code

package/dist/react/jsx/utils/parseString.js

@@ -3,7 +3,7 @@ import { buildImportMap } from './buildImportMap.js';
 import { resolveImportPath } from './resolveImportPath.js';
 import { parse } from '@babel/parser';
 import fs from 'node:fs';
-import { warnDeriveFunctionNoResultsSync, warnFunctionNotFoundSync, warnInvalidDeclareVarNameSync, } from '../../../console/index.js';
+import { warnDeriveFunctionNoResultsSync, warnFunctionNotFoundSync, warnInvalidDeclareVarNameSync, warnDeriveNonConstVariableSync, warnDeriveUnresolvableValueSync, warnDeriveOptionalChainingSync, warnDeriveDestructuringSync, warnDeriveCircularSpreadSync, } from '../../../console/index.js';
 import traverseModule from '@babel/traverse';
 import { DECLARE_VAR_FUNCTION } from '../../jsx/utils/constants.js';
 import { GT_LIBRARIES } from '../../../types/libraries.js';
@@ -21,6 +21,419 @@ const resolveImportPathCache = new Map();
  * Cache for processed functions to avoid re-parsing the same files.
  */
 const processFunctionCache = new Map();
+/**
+ * Cache for resolved object nodes to avoid re-parsing the same files.
+ */
+const resolveObjectNodeCache = new Map();
+/**
+ * Guard against infinite recursion when resolving identifier chains.
+ * Tracks AST nodes currently being resolved to detect circular references.
+ */
+const resolvingIdentifiers = new Set();
+/**
+ * Unwraps TypeScript type annotations to get the underlying expression.
+ * Handles: as, satisfies, non-null assertion (!), and angle-bracket assertions.
+ */
+function unwrapTypeAnnotation(node) {
+    if (t.isTSAsExpression(node))
+        return node.expression;
+    if (t.isTSSatisfiesExpression(node))
+        return node.expression;
+    if (t.isTSNonNullExpression(node))
+        return node.expression;
+    if (t.isTSTypeAssertion(node))
+        return node.expression;
+    return node;
+}
+/**
+ * Collects all resolvable property entries from an ObjectExpression,
+ * including entries from spread sources.
+ */
+function collectObjectProperties(objExpr, tPath, file, parsingOptions, warnings, errors = []) {
+    const entries = [];
+    for (const prop of objExpr.properties) {
+        if (t.isObjectProperty(prop)) {
+            const key = !prop.computed && t.isIdentifier(prop.key)
+                ? prop.key.name
+                : t.isStringLiteral(prop.key)
+                    ? prop.key.value
+                    : t.isNumericLiteral(prop.key)
+                        ? String(prop.key.value)
+                        : null;
+            if (t.isExpression(prop.value)) {
+                entries.push({ key, value: prop.value });
+            }
+        }
+        else if (t.isSpreadElement(prop)) {
+            // Handle inline ObjectExpression spread: { ...({ a: 'x' }) }
+            const spreadArg = unwrapTypeAnnotation(prop.argument);
+            if (t.isObjectExpression(spreadArg)) {
+                entries.push(...collectObjectProperties(spreadArg, tPath, file, parsingOptions, warnings, errors));
+                continue;
+            }
+            if (!t.isIdentifier(prop.argument))
+                continue;
+            const spreadBinding = tPath.scope.getBinding(prop.argument.name);
+            if (!spreadBinding)
+                continue;
+            // Same-file: VariableDeclarator
+            if (spreadBinding.path.isVariableDeclarator()) {
+                const spreadDecl = spreadBinding.path.parentPath;
+                if (spreadDecl?.isVariableDeclaration() &&
+                    spreadDecl.node.kind !== 'const')
+                    continue;
+                const spreadInit = spreadBinding.path.node.init;
+                if (!spreadInit)
+                    continue;
+                // Guard against circular spreads
+                if (resolvingIdentifiers.has(spreadInit)) {
+                    errors.push(warnDeriveCircularSpreadSync(file, prop.argument.name, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+                    continue;
+                }
+                resolvingIdentifiers.add(spreadInit);
+                const spreadObj = unwrapTypeAnnotation(spreadInit);
+                if (!t.isObjectExpression(spreadObj)) {
+                    resolvingIdentifiers.delete(spreadInit);
+                    continue;
+                }
+                entries.push(...collectObjectProperties(spreadObj, spreadBinding.path, file, parsingOptions, warnings, errors));
+                resolvingIdentifiers.delete(spreadInit);
+            }
+            // Cross-file: ImportSpecifier or ImportDefaultSpecifier
+            else if (spreadBinding.path.isImportSpecifier() ||
+                spreadBinding.path.isImportDefaultSpecifier()) {
+                const programPath = tPath.scope.getProgramParent().path;
+                const importMap = buildImportMap(programPath);
+                const importPath = importMap.get(prop.argument.name);
+                if (!importPath)
+                    continue;
+                let originalName = prop.argument.name;
+                if (spreadBinding.path.isImportSpecifier()) {
+                    const imported = spreadBinding.path.node.imported;
+                    originalName = t.isIdentifier(imported)
+                        ? imported.name
+                        : imported.value;
+                }
+                const resolvedFilePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
+                if (!resolvedFilePath)
+                    continue;
+                const crossFileObjects = resolveObjectNodesInFile(resolvedFilePath, originalName, parsingOptions, warnings);
+                for (const crossObj of crossFileObjects) {
+                    const crossEntries = t.isArrayExpression(crossObj.objExpr)
+                        ? collectArrayElements(crossObj.objExpr, crossObj.tPath, crossObj.file, parsingOptions, warnings)
+                        : collectObjectProperties(crossObj.objExpr, crossObj.tPath, crossObj.file, parsingOptions, warnings, errors);
+                    entries.push(...crossEntries);
+                }
+            }
+        }
+        // Skip ObjectMethod (getters, setters, methods)
+    }
+    return entries;
+}
+/**
+ * Collects elements from an ArrayExpression as ObjectEntry[] with index as key.
+ * Handles spread elements by resolving the source array.
+ */
+function collectArrayElements(arrExpr, tPath, file, parsingOptions, warnings, errors = []) {
+    const entries = [];
+    let index = 0;
+    for (const el of arrExpr.elements) {
+        if (!el) {
+            index++;
+            continue;
+        } // sparse hole
+        if (t.isSpreadElement(el)) {
+            if (!t.isIdentifier(el.argument)) {
+                continue;
+            }
+            const spreadBinding = tPath.scope.getBinding(el.argument.name);
+            if (!spreadBinding)
+                continue;
+            // Same-file spread
+            if (spreadBinding.path.isVariableDeclarator()) {
+                const spreadDecl = spreadBinding.path.parentPath;
+                if (spreadDecl?.isVariableDeclaration() &&
+                    spreadDecl.node.kind !== 'const') {
+                    errors.push(warnDeriveNonConstVariableSync(file, el.argument.name, spreadDecl.node.kind, `${el.loc?.start?.line}:${el.loc?.start?.column}`));
+                    continue;
+                }
+                const spreadInit = spreadBinding.path.node.init;
+                if (!spreadInit)
+                    continue;
+                const spreadUnwrapped = unwrapTypeAnnotation(spreadInit);
+                if (t.isArrayExpression(spreadUnwrapped)) {
+                    const spreadEntries = collectArrayElements(spreadUnwrapped, spreadBinding.path, file, parsingOptions, warnings);
+                    for (const e of spreadEntries) {
+                        entries.push({ key: String(index++), value: e.value });
+                    }
+                    continue;
+                }
+            }
+            // Cross-file spread
+            else if (spreadBinding.path.isImportSpecifier() ||
+                spreadBinding.path.isImportDefaultSpecifier()) {
+                const programPath = tPath.scope.getProgramParent().path;
+                const importMap = buildImportMap(programPath);
+                const importPath = importMap.get(el.argument.name);
+                if (!importPath)
+                    continue;
+                let originalName = el.argument.name;
+                if (spreadBinding.path.isImportSpecifier()) {
+                    const imported = spreadBinding.path.node.imported;
+                    originalName = t.isIdentifier(imported)
+                        ? imported.name
+                        : imported.value;
+                }
+                const resolvedFilePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
+                if (!resolvedFilePath)
+                    continue;
+                const crossFileNodes = resolveObjectNodesInFile(resolvedFilePath, originalName, parsingOptions, warnings);
+                for (const crossNode of crossFileNodes) {
+                    if (t.isArrayExpression(crossNode.objExpr)) {
+                        const spreadEntries = collectArrayElements(crossNode.objExpr, crossNode.tPath, crossNode.file, parsingOptions, warnings);
+                        for (const e of spreadEntries) {
+                            entries.push({ key: String(index++), value: e.value });
+                        }
+                    }
+                }
+            }
+            continue;
+        }
+        if (t.isExpression(el)) {
+            entries.push({ key: String(index), value: unwrapTypeAnnotation(el) });
+        }
+        index++;
+    }
+    return entries;
+}
+/**
+ * Resolves an expression to ObjectExpression or ArrayExpression AST node(s).
+ * Handles Identifier (local + imported) and MemberExpression (nested access chains).
+ */
+function resolveToObjectNodes(node, tPath, file, parsingOptions, warnings, errors = []) {
+    // Case 1: Identifier — base case
+    if (t.isIdentifier(node)) {
+        const binding = tPath.scope.getBinding(node.name);
+        if (!binding)
+            return [];
+        // Local variable
+        if (binding.path.isVariableDeclarator()) {
+            const declaration = binding.path.parentPath;
+            if (declaration?.isVariableDeclaration() &&
+                declaration.node.kind !== 'const') {
+                warnings.add(warnDeriveNonConstVariableSync(file, node.name, declaration.node.kind, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
+                return [];
+            }
+            const init = binding.path.node.init;
+            if (!init)
+                return [];
+            const unwrapped = unwrapTypeAnnotation(init);
+            if (t.isObjectExpression(unwrapped) || t.isArrayExpression(unwrapped)) {
+                return [{ objExpr: unwrapped, tPath: binding.path, file }];
+            }
+            // Handle identifier chain: const A = B; const B = { ... }
+            if (t.isIdentifier(unwrapped)) {
+                return resolveToObjectNodes(unwrapped, binding.path, file, parsingOptions, warnings, errors);
+            }
+            // Handle conditional: cond ? { ... } : { ... } (including nested ternaries)
+            if (t.isConditionalExpression(unwrapped)) {
+                const collectConditionalLeaves = (expr) => {
+                    const inner = unwrapTypeAnnotation(expr);
+                    if (t.isConditionalExpression(inner)) {
+                        return [
+                            ...collectConditionalLeaves(inner.consequent),
+                            ...collectConditionalLeaves(inner.alternate),
+                        ];
+                    }
+                    if (t.isObjectExpression(inner) || t.isArrayExpression(inner)) {
+                        return [{ objExpr: inner, tPath: binding.path, file }];
+                    }
+                    return [];
+                };
+                return [
+                    ...collectConditionalLeaves(unwrapped.consequent),
+                    ...collectConditionalLeaves(unwrapped.alternate),
+                ];
+            }
+            return [];
+        }
+        // Imported
+        if (binding.path.isImportSpecifier() ||
+            binding.path.isImportDefaultSpecifier()) {
+            const programPath = tPath.scope.getProgramParent().path;
+            const importMap = buildImportMap(programPath);
+            const importPath = importMap.get(node.name);
+            if (!importPath)
+                return [];
+            let originalName = node.name;
+            if (binding.path.isImportSpecifier()) {
+                const imported = binding.path.node.imported;
+                originalName = t.isIdentifier(imported)
+                    ? imported.name
+                    : imported.value;
+            }
+            const resolvedFilePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
+            if (!resolvedFilePath)
+                return [];
+            return resolveObjectNodesInFile(resolvedFilePath, originalName, parsingOptions, warnings);
+        }
+        return [];
+    }
+    // Case 2: MemberExpression — recursive
+    if (t.isMemberExpression(node)) {
+        if (!t.isExpression(node.object))
+            return [];
+        const parentObjects = resolveToObjectNodes(node.object, tPath, file, parsingOptions, warnings, errors);
+        if (parentObjects.length === 0)
+            return [];
+        const results = [];
+        for (const parent of parentObjects) {
+            const entries = t.isArrayExpression(parent.objExpr)
+                ? collectArrayElements(parent.objExpr, parent.tPath, parent.file, parsingOptions, warnings)
+                : collectObjectProperties(parent.objExpr, parent.tPath, parent.file, parsingOptions, warnings, errors);
+            // Determine if this is a static access (known key)
+            let staticKey = null;
+            if (!node.computed && t.isIdentifier(node.property)) {
+                staticKey = node.property.name;
+            }
+            else if (node.computed && t.isStringLiteral(node.property)) {
+                staticKey = node.property.value;
+            }
+            else if (node.computed && t.isNumericLiteral(node.property)) {
+                staticKey = String(node.property.value);
+            }
+            if (staticKey !== null) {
+                // Static: narrow to matching key(s) — don't break, spreads may duplicate keys
+                for (const entry of entries) {
+                    if (entry.key === staticKey) {
+                        const unwrapped = unwrapTypeAnnotation(entry.value);
+                        if (t.isObjectExpression(unwrapped) ||
+                            t.isArrayExpression(unwrapped)) {
+                            results.push({
+                                objExpr: unwrapped,
+                                tPath: parent.tPath,
+                                file: parent.file,
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                // Dynamic: collect ALL entries whose values are ObjectExpressions or ArrayExpressions
+                for (const entry of entries) {
+                    const unwrapped = unwrapTypeAnnotation(entry.value);
+                    if (t.isObjectExpression(unwrapped) ||
+                        t.isArrayExpression(unwrapped)) {
+                        results.push({
+                            objExpr: unwrapped,
+                            tPath: parent.tPath,
+                            file: parent.file,
+                        });
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    return [];
+}
+/**
+ * Resolves an object declaration from an external file.
+ * Finds a const VariableDeclarator with ObjectExpression init.
+ * Follows re-export chains.
+ */
+function resolveObjectNodesInFile(filePath, name, parsingOptions, warnings) {
+    const cacheKey = `${filePath}::${name}`;
+    if (resolveObjectNodeCache.has(cacheKey)) {
+        return resolveObjectNodeCache.get(cacheKey);
+    }
+    try {
+        const code = fs.readFileSync(filePath, 'utf8');
+        const ast = parse(code, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript'],
+        });
+        const results = [];
+        traverse(ast, {
+            VariableDeclarator(path) {
+                if (t.isIdentifier(path.node.id) &&
+                    path.node.id.name === name &&
+                    results.length === 0) {
+                    const init = path.node.init;
+                    if (!init)
+                        return;
+                    const declaration = path.parentPath;
+                    if (declaration?.isVariableDeclaration() &&
+                        declaration.node.kind !== 'const')
+                        return;
+                    const unwrapped = unwrapTypeAnnotation(init);
+                    if (t.isObjectExpression(unwrapped) ||
+                        t.isArrayExpression(unwrapped)) {
+                        results.push({
+                            objExpr: unwrapped,
+                            tPath: path,
+                            file: filePath,
+                        });
+                    }
+                }
+            },
+            ExportAllDeclaration(path) {
+                if (results.length > 0)
+                    return;
+                if (t.isStringLiteral(path.node.source)) {
+                    const reexportPath = path.node.source.value;
+                    const resolvedPath = resolveImportPath(filePath, reexportPath, parsingOptions, resolveImportPathCache);
+                    if (resolvedPath) {
+                        results.push(...resolveObjectNodesInFile(resolvedPath, name, parsingOptions, warnings));
+                    }
+                }
+            },
+            ExportNamedDeclaration(path) {
+                if (results.length > 0)
+                    return;
+                if (path.node.source && t.isStringLiteral(path.node.source)) {
+                    const hasMatch = path.node.specifiers.some((spec) => {
+                        if (t.isExportSpecifier(spec)) {
+                            const exportedName = t.isIdentifier(spec.exported)
+                                ? spec.exported.name
+                                : spec.exported.value;
+                            return exportedName === name;
+                        }
+                        return false;
+                    });
+                    if (hasMatch) {
+                        const reexportPath = path.node.source.value;
+                        const resolvedPath = resolveImportPath(filePath, reexportPath, parsingOptions, resolveImportPathCache);
+                        if (resolvedPath) {
+                            const specifier = path.node.specifiers.find((spec) => {
+                                if (t.isExportSpecifier(spec)) {
+                                    const exportedName = t.isIdentifier(spec.exported)
+                                        ? spec.exported.name
+                                        : spec.exported.value;
+                                    return exportedName === name;
+                                }
+                                return false;
+                            });
+                            let originalName = name;
+                            if (specifier &&
+                                t.isExportSpecifier(specifier) &&
+                                t.isIdentifier(specifier.local)) {
+                                originalName = specifier.local.name;
+                            }
+                            results.push(...resolveObjectNodesInFile(resolvedPath, originalName, parsingOptions, warnings));
+                        }
+                    }
+                }
+            },
+        });
+        resolveObjectNodeCache.set(cacheKey, results);
+        return results;
+    }
+    catch {
+        resolveObjectNodeCache.set(cacheKey, []);
+        return [];
+    }
+}
 /**
  * Processes a string expression node and resolves any function calls within it
  * This handles cases like:
@@ -36,7 +449,14 @@ const processFunctionCache = new Map();
  * @param warnings - Set to collect warning messages
  * @returns Node | null
  */
-export function parseStringExpression(node, tPath, file, parsingOptions, warnings = new Set()) {
+export function parseStringExpression(node, tPath, file, parsingOptions, warnings, errors) {
+    // Unwrap TypeScript type annotations (as, satisfies, !, <Type>)
+    if (t.isTSAsExpression(node) ||
+        t.isTSSatisfiesExpression(node) ||
+        t.isTSNonNullExpression(node) ||
+        t.isTSTypeAssertion(node)) {
+        return parseStringExpression(node.expression, tPath, file, parsingOptions, warnings, errors);
+    }
     // Handle string literals
     if (t.isStringLiteral(node)) {
         return { type: 'text', text: node.value };
@@ -64,7 +484,7 @@ export function parseStringExpression(node, tPath, file, parsingOptions, warning
             }
             const exprNode = node.expressions[index];
             if (exprNode && t.isExpression(exprNode)) {
-                const result = parseStringExpression(exprNode, tPath, file, parsingOptions, warnings);
+                const result = parseStringExpression(exprNode, tPath, file, parsingOptions, warnings, errors);
                 if (result === null) {
                     return null;
                 }
@@ -84,8 +504,8 @@ export function parseStringExpression(node, tPath, file, parsingOptions, warning
         if (!t.isExpression(node.left) || !t.isExpression(node.right)) {
             return null;
         }
-        const leftResult = parseStringExpression(node.left, tPath, file, parsingOptions, warnings);
-        const rightResult = parseStringExpression(node.right, tPath, file, parsingOptions, warnings);
+        const leftResult = parseStringExpression(node.left, tPath, file, parsingOptions, warnings, errors);
+        const rightResult = parseStringExpression(node.right, tPath, file, parsingOptions, warnings, errors);
         if (leftResult === null || rightResult === null) {
             return null;
         }
@@ -96,8 +516,8 @@ export function parseStringExpression(node, tPath, file, parsingOptions, warning
         if (!t.isExpression(node.consequent) || !t.isExpression(node.alternate)) {
             return null;
         }
-        const consequentResult = parseStringExpression(node.consequent, tPath, file, parsingOptions, warnings);
-        const alternateResult = parseStringExpression(node.alternate, tPath, file, parsingOptions, warnings);
+        const consequentResult = parseStringExpression(node.consequent, tPath, file, parsingOptions, warnings, errors);
+        const alternateResult = parseStringExpression(node.alternate, tPath, file, parsingOptions, warnings, errors);
         if (consequentResult === null || alternateResult === null) {
             return null;
         }
@@ -116,15 +536,116 @@ export function parseStringExpression(node, tPath, file, parsingOptions, warning
         }
         // Check if it's a const/let/var with an initializer
         if (binding.path.isVariableDeclarator() && binding.path.node.init) {
+            // Check for destructuring patterns (not yet supported)
+            if (t.isObjectPattern(binding.path.node.id) ||
+                t.isArrayPattern(binding.path.node.id)) {
+                errors.push(warnDeriveDestructuringSync(file, node.name, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
+                return null;
+            }
+            // Guard against circular references (e.g., const A = B; const B = A)
             const init = binding.path.node.init;
-            if (t.isExpression(init)) {
-                // Recursively resolve the initializer
-                return parseStringExpression(init, binding.path, file, parsingOptions, warnings);
+            if (resolvingIdentifiers.has(init)) {
+                return null;
+            }
+            // Enforce const-only
+            const declaration = binding.path.parentPath;
+            if (declaration?.isVariableDeclaration() &&
+                declaration.node.kind !== 'const') {
+                warnings.add(warnDeriveNonConstVariableSync(file, node.name, declaration.node.kind, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
+                return null;
             }
+            // Unwrap TSAsExpression (for `as const`)
+            const unwrapped = unwrapTypeAnnotation(init);
+            if (t.isExpression(unwrapped)) {
+                // Recursively resolve the initializer with recursion guard
+                resolvingIdentifiers.add(init);
+                try {
+                    return parseStringExpression(unwrapped, binding.path, file, parsingOptions, warnings, errors);
+                }
+                finally {
+                    resolvingIdentifiers.delete(init);
+                }
+            }
+        }
+        // Check for destructuring patterns (not yet supported)
+        if (binding.path.isObjectProperty() ||
+            binding.path.isArrayPattern() ||
+            binding.path.isRestElement()) {
+            errors.push(warnDeriveDestructuringSync(file, node.name, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
+            return null;
         }
         // Not a resolvable variable
         return null;
     }
+    // Handle optional chaining — not supported, emit error
+    if (t.isOptionalMemberExpression(node)) {
+        errors.push(warnDeriveOptionalChainingSync(file, generate(node).code, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
+        return null;
+    }
+    // Handle member expressions: obj[key], obj.prop, and nested obj.a.b / obj[a][b]
+    if (t.isMemberExpression(node)) {
+        if (!t.isExpression(node.object))
+            return null;
+        // Resolve the object part to ObjectExpression node(s)
+        const objectNodes = resolveToObjectNodes(node.object, tPath, file, parsingOptions, warnings, errors);
+        if (objectNodes.length === 0)
+            return null;
+        // Apply the final access to each resolved object
+        const branches = [];
+        for (const { objExpr, tPath: objPath, file: objFile } of objectNodes) {
+            const entries = t.isArrayExpression(objExpr)
+                ? collectArrayElements(objExpr, objPath, objFile, parsingOptions, warnings, errors)
+                : collectObjectProperties(objExpr, objPath, objFile, parsingOptions, warnings, errors);
+            // Check for static literal subscripts: obj['key'] or obj[0]
+            let staticLiteralKey = null;
+            if (node.computed && t.isStringLiteral(node.property)) {
+                staticLiteralKey = node.property.value;
+            }
+            else if (node.computed && t.isNumericLiteral(node.property)) {
+                staticLiteralKey = String(node.property.value);
+            }
+            // Determine the access key (if statically known)
+            const propName = staticLiteralKey ??
+                (!node.computed && t.isIdentifier(node.property)
+                    ? node.property.name
+                    : null);
+            // Check if we can narrow: need a known access key AND all object keys must be resolvable
+            const hasUnresolvableKeys = entries.some((e) => e.key === null);
+            const canNarrow = propName !== null && !hasUnresolvableKeys;
+            if (canNarrow) {
+                // STATIC: extract ONE specific property
+                for (const entry of entries) {
+                    if (entry.key === propName) {
+                        const resolved = parseStringExpression(entry.value, objPath, objFile, parsingOptions, warnings, errors);
+                        if (resolved) {
+                            branches.push(resolved);
+                        }
+                        else {
+                            errors.push(warnDeriveUnresolvableValueSync(objFile, propName, `${entry.value.loc?.start?.line}:${entry.value.loc?.start?.column}`));
+                        }
+                        // Don't break — spreads may introduce duplicate keys
+                    }
+                }
+            }
+            else {
+                // DYNAMIC: extract ALL values (can't determine which key matches)
+                for (const entry of entries) {
+                    const resolved = parseStringExpression(entry.value, objPath, objFile, parsingOptions, warnings, errors);
+                    if (resolved) {
+                        branches.push(resolved);
+                    }
+                    else if (entry.key !== null) {
+                        errors.push(warnDeriveUnresolvableValueSync(objFile, entry.key, `${entry.value.loc?.start?.line}:${entry.value.loc?.start?.column}`));
+                    }
+                }
+            }
+        }
+        if (branches.length === 0)
+            return null;
+        if (branches.length === 1)
+            return branches[0];
+        return { type: 'choice', nodes: branches };
+    }
     // Handle function calls (e.g., getName())
     if (t.isCallExpression(node) && t.isIdentifier(node.callee)) {
         const functionName = node.callee.name;
@@ -184,16 +705,16 @@ export function parseStringExpression(node, tPath, file, parsingOptions, warning
             }
             const filePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
             if (filePath && originalName) {
-                return resolveFunctionInFile(filePath, originalName, parsingOptions, warnings);
+                return resolveFunctionInFile(filePath, originalName, parsingOptions, warnings, errors);
             }
             return null;
         }
         // Resolve the function locally and get its return values
-        return resolveFunctionCall(calleeBinding, tPath, file, parsingOptions, warnings);
+        return resolveFunctionCall(calleeBinding, tPath, file, parsingOptions, warnings, errors);
     }
     // Handle parenthesized expressions
     if (t.isParenthesizedExpression(node)) {
-        return parseStringExpression(node.expression, tPath, file, parsingOptions, warnings);
+        return parseStringExpression(node.expression, tPath, file, parsingOptions, warnings, errors);
     }
     // Handle unary expressions (e.g., -123)
     if (t.isUnaryExpression(node)) {
@@ -220,7 +741,7 @@ export function parseStringExpression(node, tPath, file, parsingOptions, warning
 /**
  * Resolves a function call by traversing its body and collecting return values
  */
-function resolveFunctionCall(calleeBinding, tPath, file, parsingOptions, warnings) {
+function resolveFunctionCall(calleeBinding, tPath, file, parsingOptions, warnings, errors) {
     if (!calleeBinding) {
         return null;
     }
@@ -242,7 +763,7 @@ function resolveFunctionCall(calleeBinding, tPath, file, parsingOptions, warning
                 if (!returnArg || !t.isExpression(returnArg)) {
                     return;
                 }
-                const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings);
+                const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings, errors);
                 if (returnResult !== null) {
                     branches.push(returnResult);
                 }
@@ -258,7 +779,7 @@ function resolveFunctionCall(calleeBinding, tPath, file, parsingOptions, warning
         const body = init.get('body');
         // Handle expression body: () => "day"
         if (body.isExpression()) {
-            const bodyResult = parseStringExpression(body.node, body, file, parsingOptions, warnings);
+            const bodyResult = parseStringExpression(body.node, body, file, parsingOptions, warnings, errors);
             if (bodyResult !== null) {
                 branches.push(bodyResult);
             }
@@ -280,7 +801,7 @@ function resolveFunctionCall(calleeBinding, tPath, file, parsingOptions, warning
                     if (!returnArg || !t.isExpression(returnArg)) {
                         return;
                     }
-                    const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings);
+                    const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings, errors);
                     if (returnResult !== null) {
                         branches.push(returnResult);
                     }
@@ -299,7 +820,7 @@ function resolveFunctionCall(calleeBinding, tPath, file, parsingOptions, warning
 /**
  * Resolves a function definition in an external file
  */
-function resolveFunctionInFile(filePath, functionName, parsingOptions, warnings) {
+function resolveFunctionInFile(filePath, functionName, parsingOptions, warnings, errors) {
     // Check cache first
     const cacheKey = `${filePath}::${functionName}`;
     if (processFunctionCache.has(cacheKey)) {
@@ -323,7 +844,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, warnings)
                     const resolvedPath = resolveImportPath(filePath, reexportPath, parsingOptions, resolveImportPathCache);
                     if (resolvedPath) {
                         // Recursively resolve in the re-exported file
-                        const reexportResult = resolveFunctionInFile(resolvedPath, functionName, parsingOptions, warnings);
+                        const reexportResult = resolveFunctionInFile(resolvedPath, functionName, parsingOptions, warnings, errors);
                         if (reexportResult) {
                             result = reexportResult;
                         }
@@ -368,7 +889,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, warnings)
                                 originalName = specifier.local.name;
                             }
                             // Recursively resolve in the re-exported file
-                            const reexportResult = resolveFunctionInFile(resolvedPath, originalName, parsingOptions, warnings);
+                            const reexportResult = resolveFunctionInFile(resolvedPath, originalName, parsingOptions, warnings, errors);
                             if (reexportResult) {
                                 result = reexportResult;
                             }
@@ -393,7 +914,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, warnings)
                             if (!returnArg || !t.isExpression(returnArg)) {
                                 return;
                             }
-                            const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings);
+                            const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings, errors);
                             if (returnResult !== null) {
                                 branches.push(returnResult);
                             }
@@ -411,58 +932,121 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, warnings)
             VariableDeclarator(path) {
                 if (t.isIdentifier(path.node.id) &&
                     path.node.id.name === functionName &&
-                    path.node.init &&
-                    (t.isArrowFunctionExpression(path.node.init) ||
-                        t.isFunctionExpression(path.node.init)) &&
                     result === null) {
-                    const init = path.get('init');
-                    if (!init.isArrowFunctionExpression() &&
-                        !init.isFunctionExpression()) {
+                    const init = path.node.init;
+                    if (!init)
                         return;
-                    }
-                    const bodyPath = init.get('body');
-                    const branches = [];
-                    // Handle expression body: () => "day"
-                    if (!Array.isArray(bodyPath) && t.isExpression(bodyPath.node)) {
-                        const bodyResult = parseStringExpression(bodyPath.node, bodyPath, filePath, parsingOptions, warnings);
-                        if (bodyResult !== null) {
-                            branches.push(bodyResult);
+                    // Handle arrow/function expressions
+                    if (t.isArrowFunctionExpression(init) ||
+                        t.isFunctionExpression(init)) {
+                        const initPath = path.get('init');
+                        if (!initPath.isArrowFunctionExpression() &&
+                            !initPath.isFunctionExpression()) {
+                            return;
+                        }
+                        const bodyPath = initPath.get('body');
+                        const branches = [];
+                        // Handle expression body: () => "day"
+                        if (!Array.isArray(bodyPath) && t.isExpression(bodyPath.node)) {
+                            const bodyResult = parseStringExpression(bodyPath.node, bodyPath, filePath, parsingOptions, warnings, errors);
+                            if (bodyResult !== null) {
+                                branches.push(bodyResult);
+                            }
+                        }
+                        // Handle block body: () => { return "day"; }
+                        else if (!Array.isArray(bodyPath) &&
+                            t.isBlockStatement(bodyPath.node)) {
+                            const arrowFunction = initPath.node;
+                            bodyPath.traverse({
+                                Function(innerPath) {
+                                    // Skip nested functions
+                                    innerPath.skip();
+                                },
+                                ReturnStatement(returnPath) {
+                                    // Only process return statements that are direct children of this function
+                                    const parentFunction = returnPath.getFunctionParent();
+                                    if (parentFunction?.node !== arrowFunction) {
+                                        return;
+                                    }
+                                    if (!t.isReturnStatement(returnPath.node)) {
+                                        return;
+                                    }
+                                    const returnArg = returnPath.node.argument;
+                                    if (!returnArg || !t.isExpression(returnArg)) {
+                                        return;
+                                    }
+                                    const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings, errors);
+                                    if (returnResult !== null) {
+                                        branches.push(returnResult);
+                                    }
+                                },
+                            });
+                        }
+                        if (branches.length === 1) {
+                            result = branches[0];
+                        }
+                        else if (branches.length > 1) {
+                            result = { type: 'choice', nodes: branches };
                         }
                     }
-                    // Handle block body: () => { return "day"; }
-                    else if (!Array.isArray(bodyPath) &&
-                        t.isBlockStatement(bodyPath.node)) {
-                        const arrowFunction = init.node;
-                        bodyPath.traverse({
-                            Function(innerPath) {
-                                // Skip nested functions
-                                innerPath.skip();
-                            },
-                            ReturnStatement(returnPath) {
-                                // Only process return statements that are direct children of this function
-                                const parentFunction = returnPath.getFunctionParent();
-                                if (parentFunction?.node !== arrowFunction) {
-                                    return;
-                                }
-                                if (!t.isReturnStatement(returnPath.node)) {
-                                    return;
-                                }
-                                const returnArg = returnPath.node.argument;
-                                if (!returnArg || !t.isExpression(returnArg)) {
-                                    return;
-                                }
-                                const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings);
-                                if (returnResult !== null) {
-                                    branches.push(returnResult);
-                                }
-                            },
-                        });
+                    // Handle string/numeric/boolean/null constants
+                    else if (t.isStringLiteral(init)) {
+                        result = { type: 'text', text: init.value };
                     }
-                    if (branches.length === 1) {
-                        result = branches[0];
+                    else if (t.isNumericLiteral(init)) {
+                        result = { type: 'text', text: String(init.value) };
                     }
-                    else if (branches.length > 1) {
-                        result = { type: 'choice', nodes: branches };
+                    else if (t.isBooleanLiteral(init)) {
+                        result = { type: 'text', text: String(init.value) };
+                    }
+                    // Handle template literals
+                    else if (t.isTemplateLiteral(init)) {
+                        const parts = [];
+                        let failed = false;
+                        for (let index = 0; index < init.quasis.length; index++) {
+                            const quasi = init.quasis[index];
+                            const text = quasi.value.cooked ?? quasi.value.raw ?? '';
+                            if (text) {
+                                parts.push({ type: 'text', text });
+                            }
+                            const exprNode = init.expressions[index];
+                            if (exprNode && t.isExpression(exprNode)) {
+                                const exprResult = parseStringExpression(exprNode, path, filePath, parsingOptions, warnings, errors);
+                                if (exprResult === null) {
+                                    failed = true;
+                                    break;
+                                }
+                                parts.push(exprResult);
+                            }
+                        }
+                        if (!failed) {
+                            if (parts.length === 0) {
+                                result = { type: 'text', text: '' };
+                            }
+                            else if (parts.length === 1) {
+                                result = parts[0];
+                            }
+                            else {
+                                result = { type: 'sequence', nodes: parts };
+                            }
+                        }
+                    }
+                    // Handle object expressions (and `as const` / `satisfies`)
+                    else if (t.isObjectExpression(init) ||
+                        t.isObjectExpression(unwrapTypeAnnotation(init))) {
+                        const objExpr = unwrapTypeAnnotation(init);
+                        const branches = [];
+                        for (const prop of objExpr.properties) {
+                            if (!t.isObjectProperty(prop) || !t.isExpression(prop.value))
+                                continue;
+                            const resolved = parseStringExpression(prop.value, path, filePath, parsingOptions, warnings, errors);
+                            if (resolved)
+                                branches.push(resolved);
+                        }
+                        if (branches.length === 1)
+                            result = branches[0];
+                        else if (branches.length > 1)
+                            result = { type: 'choice', nodes: branches };
                     }
                 }
             },

package/dist/react/jsx/utils/stringParsing/derivation/handleDerivation.d.ts

@@ -18,12 +18,13 @@ export type StringTree = (string | StringTree)[];
  *  - Only provide at entry for template macros, otherwise omit
  *  - t`Hello {nonDerivableValue}` -> t`Hello {0}`
  */
-export declare function handleDerivation({ expr, tPath, file, parsingOptions, errors, runtimeInterpolationState, }: {
+export declare function handleDerivation({ expr, tPath, file, parsingOptions, errors, warnings, runtimeInterpolationState, }: {
     expr: t.Expression;
     tPath: NodePath;
     file: string;
     parsingOptions: ParsingConfigOptions;
     errors: string[];
+    warnings: Set<string>;
     runtimeInterpolationState?: {
         index: number;
     };

package/dist/react/jsx/utils/stringParsing/derivation/handleDerivation.js

@@ -38,7 +38,7 @@ const processFunctionCache = new Map();
  *  - Only provide at entry for template macros, otherwise omit
  *  - t`Hello {nonDerivableValue}` -> t`Hello {0}`
  */
-export function handleDerivation({ expr, tPath, file, parsingOptions, errors, runtimeInterpolationState, }) {
+export function handleDerivation({ expr, tPath, file, parsingOptions, errors, warnings, runtimeInterpolationState, }) {
     if (!expr) {
         return null;
     }
@@ -51,6 +51,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, ru
                 file,
                 parsingOptions,
                 errors,
+                warnings,
             });
             if (variants) {
                 return {
@@ -98,6 +99,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, ru
                         file,
                         parsingOptions,
                         errors,
+                        warnings,
                     });
                     if (result === null)
                         return null;
@@ -111,6 +113,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, ru
                         file,
                         parsingOptions,
                         errors,
+                        warnings,
                         runtimeInterpolationState,
                     });
                     if (result === null)
@@ -138,6 +141,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, ru
             file,
             parsingOptions,
             errors,
+            warnings,
             runtimeInterpolationState,
         });
         const rightResult = handleDerivation({
@@ -146,6 +150,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, ru
             file,
             parsingOptions,
             errors,
+            warnings,
             runtimeInterpolationState,
         });
         if (leftResult === null || rightResult === null) {
@@ -161,6 +166,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, ru
             file,
             parsingOptions,
             errors,
+            warnings,
             runtimeInterpolationState,
         });
     }
@@ -214,7 +220,7 @@ export function handleDerivation({ expr, tPath, file, parsingOptions, errors, ru
  *
  * Returns null if it can't be resolved.
  */
-function getDeriveVariants({ call, tPath, file, parsingOptions, errors, }) {
+function getDeriveVariants({ call, tPath, file, parsingOptions, errors, warnings, }) {
     // --- Validate Callee --- //
     // Must be a derive(...) call or an alias of it
     if (!isDeriveCall({ expr: call, tPath })) {
@@ -233,12 +239,12 @@ function getDeriveVariants({ call, tPath, file, parsingOptions, errors, }) {
     // Handle await expression: derive(await time())
     if (t.isAwaitExpression(arg)) {
         // Resolve the inner call's possible string outcomes
-        return resolveCallStringVariants(arg.argument, tPath, file, parsingOptions, errors);
+        return resolveCallStringVariants(arg.argument, tPath, file, parsingOptions, errors, warnings);
     }
     // Resolve the inner call's possible string outcomes
-    return resolveCallStringVariants(arg, tPath, file, parsingOptions, errors);
+    return resolveCallStringVariants(arg, tPath, file, parsingOptions, errors, warnings);
 }
-function resolveCallStringVariants(expression, tPath, file, parsingOptions, errors) {
+function resolveCallStringVariants(expression, tPath, file, parsingOptions, errors, warnings) {
     // Handle function identifier calls: derive(time())
     if (t.isCallExpression(expression) && t.isIdentifier(expression.callee)) {
         const functionName = expression.callee.name;
@@ -268,7 +274,7 @@ function resolveCallStringVariants(expression, tPath, file, parsingOptions, erro
                 if (importPath) {
                     const filePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
                     if (filePath && originalName) {
-                        const node = resolveFunctionInFile(filePath, originalName, parsingOptions, errors);
+                        const node = resolveFunctionInFile(filePath, originalName, parsingOptions, errors, warnings);
                         if (node) {
                             return nodeToStrings(node);
                         }
@@ -277,7 +283,7 @@ function resolveCallStringVariants(expression, tPath, file, parsingOptions, erro
             }
             else {
                 // Function is local - use parseStringExpression with resolveFunctionCall
-                const node = resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptions);
+                const node = resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptions, warnings, errors);
                 if (node) {
                     return nodeToStrings(node);
                 }
@@ -290,7 +296,7 @@ function resolveCallStringVariants(expression, tPath, file, parsingOptions, erro
         }
     }
     // If we get here: analyze this call as derivable (statically analyzable)
-    const node = parseStringExpression(expression, tPath, file, parsingOptions);
+    const node = parseStringExpression(expression, tPath, file, parsingOptions, warnings, errors);
     if (node) {
         return nodeToStrings(node);
     }
@@ -299,7 +305,7 @@ function resolveCallStringVariants(expression, tPath, file, parsingOptions, erro
 /**
  * Resolves a function from a binding (local function) using parseStringExpression logic
  */
-function resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptions) {
+function resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptions, warnings, errors) {
     if (!calleeBinding) {
         return null;
     }
@@ -318,7 +324,7 @@ function resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptio
                 if (!returnArg || !t.isExpression(returnArg)) {
                     return;
                 }
-                const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions);
+                const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings, errors);
                 if (returnResult !== null) {
                     branches.push(returnResult);
                 }
@@ -334,7 +340,7 @@ function resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptio
         const body = init.get('body');
         // Handle expression body: () => "day"
         if (body.isExpression()) {
-            const bodyResult = parseStringExpression(body.node, body, file, parsingOptions);
+            const bodyResult = parseStringExpression(body.node, body, file, parsingOptions, warnings, errors);
             if (bodyResult !== null) {
                 branches.push(bodyResult);
             }
@@ -353,7 +359,7 @@ function resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptio
                     if (!returnArg || !t.isExpression(returnArg)) {
                         return;
                     }
-                    const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions);
+                    const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings, errors);
                     if (returnResult !== null) {
                         branches.push(returnResult);
                     }
@@ -372,7 +378,7 @@ function resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptio
 /**
  * Resolves a function definition in an external file
  */
-function resolveFunctionInFile(filePath, functionName, parsingOptions, errors) {
+function resolveFunctionInFile(filePath, functionName, parsingOptions, errors, warnings) {
     // Check cache first
     const cacheKey = `${filePath}::${functionName}`;
     if (processFunctionCache.has(cacheKey)) {
@@ -396,7 +402,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, errors) {
                     const resolvedPath = resolveImportPath(filePath, reexportPath, parsingOptions, resolveImportPathCache);
                     if (resolvedPath) {
                         // Recursively resolve in the re-exported file
-                        const reexportResult = resolveFunctionInFile(resolvedPath, functionName, parsingOptions, errors);
+                        const reexportResult = resolveFunctionInFile(resolvedPath, functionName, parsingOptions, errors, warnings);
                         if (reexportResult) {
                             result = reexportResult;
                         }
@@ -441,7 +447,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, errors) {
                                 originalName = specifier.local.name;
                             }
                             // Recursively resolve in the re-exported file
-                            const reexportResult = resolveFunctionInFile(resolvedPath, originalName, parsingOptions, errors);
+                            const reexportResult = resolveFunctionInFile(resolvedPath, originalName, parsingOptions, errors, warnings);
                             if (reexportResult) {
                                 result = reexportResult;
                             }
@@ -466,7 +472,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, errors) {
                             if (!returnArg || !t.isExpression(returnArg)) {
                                 return;
                             }
-                            const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions);
+                            const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings, errors);
                             if (returnResult !== null) {
                                 branches.push(returnResult);
                             }
@@ -497,7 +503,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, errors) {
                     const branches = [];
                     // Handle expression body: () => "day"
                     if (!Array.isArray(bodyPath) && t.isExpression(bodyPath.node)) {
-                        const bodyResult = parseStringExpression(bodyPath.node, bodyPath, filePath, parsingOptions);
+                        const bodyResult = parseStringExpression(bodyPath.node, bodyPath, filePath, parsingOptions, warnings, errors);
                         if (bodyResult !== null) {
                             branches.push(bodyResult);
                         }
@@ -524,7 +530,7 @@ function resolveFunctionInFile(filePath, functionName, parsingOptions, errors) {
                                 if (!returnArg || !t.isExpression(returnArg)) {
                                     return;
                                 }
-                                const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions);
+                                const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings, errors);
                                 if (returnResult !== null) {
                                     branches.push(returnResult);
                                 }

package/dist/react/jsx/utils/stringParsing/derivation/index.js

@@ -27,6 +27,7 @@ export function deriveExpression({ tPath, expr, metadata, config, output, index,
         file: config.file,
         parsingOptions: config.parsingOptions,
         errors: output.errors,
+        warnings: output.warnings,
         runtimeInterpolationState: enableRuntimeInterpolation
             ? { index: 0 }
             : undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.11.3",
+  "version": "2.12.0",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -110,8 +110,8 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
+    "@generaltranslation/python-extractor": "0.2.0",
     "generaltranslation": "8.1.20",
-    "@generaltranslation/python-extractor": "0.1.6",
     "gt-remark": "1.0.6"
   },
   "devDependencies": {