gtx-cli 2.5.0-alpha.3 → 2.5.1

package/dist/react/jsx/utils/jsxParsing/parseTProps.d.ts

@@ -0,0 +1,8 @@
+import { Metadata } from 'generaltranslation/types';
+import * as t from '@babel/types';
+export declare function parseTProps({ openingElement, metadata, componentErrors, file, }: {
+    openingElement: t.JSXOpeningElement;
+    metadata: Metadata;
+    componentErrors: string[];
+    file: string;
+}): void;

package/dist/react/jsx/utils/jsxParsing/parseTProps.js

@@ -0,0 +1,47 @@
+import * as t from '@babel/types';
+import generateModule from '@babel/generator';
+// Handle CommonJS/ESM interop
+const generate = generateModule.default || generateModule;
+import { GT_ATTRIBUTES, mapAttributeName } from '../constants.js';
+import { isStaticExpression } from '../../evaluateJsx.js';
+import { warnVariablePropSync } from '../../../../console/index.js';
+// Parse the props of a <T> component
+export function parseTProps({ openingElement, metadata, componentErrors, file, }) {
+    openingElement.attributes.forEach((attr) => {
+        if (!t.isJSXAttribute(attr))
+            return;
+        const attrName = attr.name.name;
+        if (typeof attrName !== 'string')
+            return;
+        if (attr.value) {
+            // If it's a plain string literal like id="hello"
+            if (t.isStringLiteral(attr.value)) {
+                metadata[attrName] = attr.value.value;
+            }
+            // If it's an expression container like id={"hello"}, id={someVar}, etc.
+            else if (t.isJSXExpressionContainer(attr.value)) {
+                const expr = attr.value.expression;
+                const code = generate(expr).code;
+                // Only check for static expressions on id and context props
+                if (GT_ATTRIBUTES.includes(attrName)) {
+                    const staticAnalysis = isStaticExpression(expr);
+                    if (!staticAnalysis.isStatic) {
+                        componentErrors.push(warnVariablePropSync(file, attrName, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+                    }
+                    // Use the static value if available
+                    if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
+                        metadata[mapAttributeName(attrName)] = staticAnalysis.value;
+                    }
+                    else {
+                        // Only store the code if we couldn't extract a static value
+                        metadata[attrName] = code;
+                    }
+                }
+                else {
+                    // For other attributes that aren't id or context
+                    metadata[attrName] = code;
+                }
+            }
+        }
+    });
+}

package/dist/react/jsx/utils/jsxParsing/removeNullChildrenFields.d.ts

@@ -0,0 +1,2 @@
+import { JsxChildren } from 'generaltranslation/types';
+export declare function removeNullChildrenFields(tree: JsxChildren): JsxChildren;

package/dist/react/jsx/utils/jsxParsing/removeNullChildrenFields.js

@@ -0,0 +1,61 @@
+import { isVariable } from 'generaltranslation/internal';
+export function removeNullChildrenFields(tree) {
+    return handleChildren(tree);
+    function handleChildren(children) {
+        if (Array.isArray(children)) {
+            return children.filter((child) => child != null).map(handleChild);
+        }
+        return handleChild(children);
+    }
+    function handleChild(child) {
+        if (typeof child === 'string') {
+            return child;
+        }
+        if (typeof child !== 'object' || child === null) {
+            return child;
+        }
+        if (isVariable(child)) {
+            return child;
+        }
+        // other fields
+        let t;
+        if (child && 't' in child && child.t != null) {
+            t = child.t;
+        }
+        let i;
+        if (child && 'i' in child && child.i != null) {
+            i = child.i;
+        }
+        // gtprop
+        let d;
+        if (child && 'd' in child && child.d != null) {
+            let b;
+            if (child.d && 'b' in child.d && child.d.b != null) {
+                b = {
+                    ...Object.fromEntries(Object.entries(child.d.b).map(([key, value]) => [
+                        key,
+                        handleChildren(value),
+                    ])),
+                };
+            }
+            d = {
+                ...(b != null && { b }),
+                ...(child.d?.t != null && { t: child.d.t }),
+                ...Object.fromEntries(Object.entries(child.d)
+                    .filter(([key, value]) => key !== 'b' && key !== 't' && value != null)
+                    .map(([key, value]) => [key, value])),
+            };
+        }
+        // children
+        let c;
+        if (child && 'c' in child && child.c != null) {
+            c = handleChildren(child.c);
+        }
+        return {
+            ...(t != null && { t }),
+            ...(i != null && { i }),
+            ...(d != null && { d }),
+            ...(c != null && { c }),
+        };
+    }
+}

package/dist/react/jsx/utils/jsxParsing/types.d.ts

@@ -0,0 +1,48 @@
+type MultiplicationNode = {
+    nodeType: 'multiplication';
+    branches: (JsxTree | MultiplicationNode)[];
+};
+type ExpressionNode = {
+    nodeType: 'expression';
+    result: string | number | boolean | MultiplicationNode | null;
+};
+type ElementNode = {
+    nodeType: 'element';
+    type: string;
+    props?: {
+        children?: JsxTree | MultiplicationNode | (JsxTree | MultiplicationNode)[];
+        [key: string]: any;
+    };
+};
+type JsxTree = ElementNode | ExpressionNode | string | number | boolean | null;
+export type { MultiplicationNode, ExpressionNode, ElementNode, JsxTree };
+declare function isElementNode(node: JsxTree | MultiplicationNode): node is ElementNode;
+declare function isExpressionNode(node: JsxTree | MultiplicationNode): node is ExpressionNode;
+declare function isMultiplicationNode(node: JsxTree | MultiplicationNode): node is MultiplicationNode;
+export { isElementNode, isExpressionNode, isMultiplicationNode };
+type WhitespaceMultiplicationNode = {
+    nodeType: 'multiplication';
+    branches: (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
+};
+type WhitespaceJsxTree = {
+    nodeType?: 'element';
+    type: string;
+    props?: {
+        children?: (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
+        [key: string]: any;
+    };
+};
+type WhitespaceJsxTreeResult = WhitespaceJsxTree | string | number | boolean | null;
+export type { WhitespaceMultiplicationNode, WhitespaceJsxTree, WhitespaceJsxTreeResult, };
+declare function isWhitespaceJsxTree(node: WhitespaceJsxTreeResult | WhitespaceMultiplicationNode): node is WhitespaceJsxTree;
+declare function isWhitespaceMultiplicationNode(node: WhitespaceJsxTreeResult | WhitespaceMultiplicationNode): node is WhitespaceMultiplicationNode;
+export { isWhitespaceJsxTree, isWhitespaceMultiplicationNode };
+type MultipliedTree = {
+    nodeType?: 'element';
+    type: string;
+    props?: {
+        children?: MultipliedTreeNode;
+    };
+};
+type MultipliedTreeNode = MultipliedTree | string | number | boolean | null;
+export type { MultipliedTree, MultipliedTreeNode };

package/dist/react/jsx/utils/jsxParsing/types.js

@@ -0,0 +1,34 @@
+// ----- Helpers ----- //
+function isElementNode(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        'nodeType' in node &&
+        node.nodeType === 'element');
+}
+function isExpressionNode(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        'nodeType' in node &&
+        node.nodeType === 'expression');
+}
+function isMultiplicationNode(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        'nodeType' in node &&
+        node.nodeType === 'multiplication');
+}
+export { isElementNode, isExpressionNode, isMultiplicationNode };
+// ----- Helpers ----- //
+function isWhitespaceJsxTree(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        'nodeType' in node &&
+        node.nodeType === 'element');
+}
+function isWhitespaceMultiplicationNode(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        'nodeType' in node &&
+        node.nodeType === 'multiplication');
+}
+export { isWhitespaceJsxTree, isWhitespaceMultiplicationNode };

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

@@ -8,12 +8,9 @@ import traverseModule from '@babel/traverse';
 const generate = generateModule.default || generateModule;
 const traverse = traverseModule.default || traverseModule;
 import fs from 'node:fs';
-import path from 'node:path';
 import { parse } from '@babel/parser';
-import { createMatchPath, loadConfig } from 'tsconfig-paths';
-import resolve from 'resolve';
-import enhancedResolve from 'enhanced-resolve';
-const { ResolverFactory } = enhancedResolve;
+import { resolveImportPath } from './resolveImportPath.js';
+import { buildImportMap } from './buildImportMap.js';
 /**
  * Cache for resolved import paths to avoid redundant I/O operations.
  * Key: `${currentFile}::${importPath}`
@@ -112,35 +109,6 @@ function extractParameterName(param) {
     }
     return null;
 }
-/**
- * Builds a map of imported function names to their import paths from a given program path.
- * Handles both named imports and default imports.
- *
- * Example: import { getInfo } from './constants' -> Map { 'getInfo' => './constants' }
- * Example: import utils from './utils' -> Map { 'utils' => './utils' }
- */
-function buildImportMap(programPath) {
-    const importMap = new Map();
-    programPath.traverse({
-        ImportDeclaration(importPath) {
-            if (t.isStringLiteral(importPath.node.source)) {
-                const importSource = importPath.node.source.value;
-                importPath.node.specifiers.forEach((spec) => {
-                    if (t.isImportSpecifier(spec) &&
-                        t.isIdentifier(spec.imported) &&
-                        t.isIdentifier(spec.local)) {
-                        importMap.set(spec.local.name, importSource);
-                    }
-                    else if (t.isImportDefaultSpecifier(spec) &&
-                        t.isIdentifier(spec.local)) {
-                        importMap.set(spec.local.name, importSource);
-                    }
-                });
-            }
-        },
-    });
-    return importMap;
-}
 /**
  * Recursively resolves variable assignments to find all aliases of a translation callback parameter.
  * Handles cases like: const t = translate; const a = translate; const b = a; const c = b;
@@ -212,7 +180,7 @@ function handleFunctionCall(tPath, updates, errors, warnings, file, importMap, i
             // If not found locally, check if it's an imported function
             else if (importMap.has(callee.name)) {
                 const importPath = importMap.get(callee.name);
-                const resolvedPath = resolveImportPath(file, importPath, parsingOptions);
+                const resolvedPath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
                 if (resolvedPath) {
                     processFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, warnings, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
                 }
@@ -263,111 +231,6 @@ function findFunctionParameterUsage(functionPath, parameterName, updates, errors
         });
     }
 }
-/**
- * Resolves import paths to absolute file paths using battle-tested libraries.
- * Handles relative paths, TypeScript paths, and node module resolution.
- *
- * Examples:
- * - './constants' -> '/full/path/to/constants.ts'
- * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
- * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
- */
-function resolveImportPath(currentFile, importPath, parsingOptions) {
-    // Check cache first
-    const cacheKey = `${currentFile}::${importPath}`;
-    if (resolveImportPathCache.has(cacheKey)) {
-        return resolveImportPathCache.get(cacheKey);
-    }
-    const basedir = path.dirname(currentFile);
-    const extensions = ['.tsx', '.ts', '.jsx', '.js'];
-    const mainFields = ['module', 'main'];
-    let result = null;
-    // 1. Try tsconfig-paths resolution first (handles TypeScript path mapping)
-    const tsConfigResult = loadConfig(basedir);
-    if (tsConfigResult.resultType === 'success') {
-        const matchPath = createMatchPath(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, mainFields);
-        // First try without any extension
-        let tsResolved = matchPath(importPath);
-        if (tsResolved && fs.existsSync(tsResolved)) {
-            result = tsResolved;
-            resolveImportPathCache.set(cacheKey, result);
-            return result;
-        }
-        // Then try with each extension
-        for (const ext of extensions) {
-            tsResolved = matchPath(importPath + ext);
-            if (tsResolved && fs.existsSync(tsResolved)) {
-                result = tsResolved;
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            // Also try the resolved path with extension
-            tsResolved = matchPath(importPath);
-            if (tsResolved) {
-                const resolvedWithExt = tsResolved + ext;
-                if (fs.existsSync(resolvedWithExt)) {
-                    result = resolvedWithExt;
-                    resolveImportPathCache.set(cacheKey, result);
-                    return result;
-                }
-            }
-        }
-    }
-    // 2. Try enhanced-resolve (handles package.json exports field and modern resolution)
-    try {
-        const resolver = ResolverFactory.createResolver({
-            useSyncFileSystemCalls: true,
-            fileSystem: fs,
-            extensions,
-            // Include 'development' condition to resolve to source files in monorepos
-            conditionNames: parsingOptions.conditionNames, // defaults to ['browser', 'module', 'import', 'require', 'default']. See generateSettings.ts for more details
-            exportsFields: ['exports'],
-            mainFields,
-        });
-        const resolved = resolver.resolveSync({}, basedir, importPath);
-        if (resolved) {
-            result = resolved;
-            resolveImportPathCache.set(cacheKey, result);
-            return result;
-        }
-    }
-    catch {
-        // Fall through to next resolution strategy
-    }
-    // 3. Fallback to Node.js resolution (handles relative paths and node_modules)
-    try {
-        result = resolve.sync(importPath, { basedir, extensions });
-        resolveImportPathCache.set(cacheKey, result);
-        return result;
-    }
-    catch {
-        // If resolution fails, try to manually replace .js/.jsx with .ts/.tsx for source files
-        if (importPath.endsWith('.js')) {
-            const tsPath = importPath.replace(/\.js$/, '.ts');
-            try {
-                result = resolve.sync(tsPath, { basedir, extensions });
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        else if (importPath.endsWith('.jsx')) {
-            const tsxPath = importPath.replace(/\.jsx$/, '.tsx');
-            try {
-                result = resolve.sync(tsxPath, { basedir, extensions });
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        resolveImportPathCache.set(cacheKey, null);
-        return null;
-    }
-}
 /**
  * Searches for a specific user-defined function in a file and analyzes how a translation callback
  * parameter (at argIndex position) is used within that function.
@@ -446,7 +309,7 @@ function processFunctionInFile(filePath, functionName, argIndex, updates, errors
         // If function not found, follow re-exports
         if (!found && reExports.length > 0) {
             for (const reExportPath of reExports) {
-                const resolvedPath = resolveImportPath(filePath, reExportPath, parsingOptions);
+                const resolvedPath = resolveImportPath(filePath, reExportPath, parsingOptions, resolveImportPathCache);
                 if (resolvedPath) {
                     processFunctionInFile(resolvedPath, functionName, argIndex, updates, errors, warnings, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions, visited);
                 }

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

@@ -0,0 +1,11 @@
+import { ParsingConfigOptions } from '../../../types/parsing.js';
+/**
+ * Resolves import paths to absolute file paths using battle-tested libraries.
+ * Handles relative paths, TypeScript paths, and node module resolution.
+ *
+ * Examples:
+ * - './constants' -> '/full/path/to/constants.ts'
+ * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
+ * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
+ */
+export declare function resolveImportPath(currentFile: string, importPath: string, parsingOptions: ParsingConfigOptions, resolveImportPathCache: Map<string, string | null>): string | null;

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

@@ -0,0 +1,111 @@
+import { createMatchPath, loadConfig } from 'tsconfig-paths';
+import fs from 'node:fs';
+import path from 'node:path';
+import resolve from 'resolve';
+import enhancedResolve from 'enhanced-resolve';
+const { ResolverFactory } = enhancedResolve;
+/**
+ * Resolves import paths to absolute file paths using battle-tested libraries.
+ * Handles relative paths, TypeScript paths, and node module resolution.
+ *
+ * Examples:
+ * - './constants' -> '/full/path/to/constants.ts'
+ * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
+ * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
+ */
+export function resolveImportPath(currentFile, importPath, parsingOptions, resolveImportPathCache) {
+    // Check cache first
+    const cacheKey = `${currentFile}::${importPath}`;
+    if (resolveImportPathCache.has(cacheKey)) {
+        return resolveImportPathCache.get(cacheKey);
+    }
+    const basedir = path.dirname(currentFile);
+    const extensions = ['.tsx', '.ts', '.jsx', '.js'];
+    const mainFields = ['module', 'main'];
+    let result = null;
+    // 1. Try tsconfig-paths resolution first (handles TypeScript path mapping)
+    const tsConfigResult = loadConfig(basedir);
+    if (tsConfigResult.resultType === 'success') {
+        const matchPath = createMatchPath(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, mainFields);
+        // First try without any extension
+        let tsResolved = matchPath(importPath);
+        if (tsResolved && fs.existsSync(tsResolved)) {
+            result = tsResolved;
+            resolveImportPathCache.set(cacheKey, result);
+            return result;
+        }
+        // Then try with each extension
+        for (const ext of extensions) {
+            tsResolved = matchPath(importPath + ext);
+            if (tsResolved && fs.existsSync(tsResolved)) {
+                result = tsResolved;
+                resolveImportPathCache.set(cacheKey, result);
+                return result;
+            }
+            // Also try the resolved path with extension
+            tsResolved = matchPath(importPath);
+            if (tsResolved) {
+                const resolvedWithExt = tsResolved + ext;
+                if (fs.existsSync(resolvedWithExt)) {
+                    result = resolvedWithExt;
+                    resolveImportPathCache.set(cacheKey, result);
+                    return result;
+                }
+            }
+        }
+    }
+    // 2. Try enhanced-resolve (handles package.json exports field and modern resolution)
+    try {
+        const resolver = ResolverFactory.createResolver({
+            useSyncFileSystemCalls: true,
+            fileSystem: fs,
+            extensions,
+            // Include 'development' condition to resolve to source files in monorepos
+            conditionNames: parsingOptions.conditionNames, // defaults to ['browser', 'module', 'import', 'require', 'default']. See generateSettings.ts for more details
+            exportsFields: ['exports'],
+            mainFields,
+        });
+        const resolved = resolver.resolveSync({}, basedir, importPath);
+        if (resolved) {
+            result = resolved;
+            resolveImportPathCache.set(cacheKey, result);
+            return result;
+        }
+    }
+    catch {
+        // Fall through to next resolution strategy
+    }
+    // 3. Fallback to Node.js resolution (handles relative paths and node_modules)
+    try {
+        result = resolve.sync(importPath, { basedir, extensions });
+        resolveImportPathCache.set(cacheKey, result);
+        return result;
+    }
+    catch {
+        // If resolution fails, try to manually replace .js/.jsx with .ts/.tsx for source files
+        if (importPath.endsWith('.js')) {
+            const tsPath = importPath.replace(/\.js$/, '.ts');
+            try {
+                result = resolve.sync(tsPath, { basedir, extensions });
+                resolveImportPathCache.set(cacheKey, result);
+                return result;
+            }
+            catch {
+                // Continue to return null
+            }
+        }
+        else if (importPath.endsWith('.jsx')) {
+            const tsxPath = importPath.replace(/\.jsx$/, '.tsx');
+            try {
+                result = resolve.sync(tsxPath, { basedir, extensions });
+                resolveImportPathCache.set(cacheKey, result);
+                return result;
+            }
+            catch {
+                // Continue to return null
+            }
+        }
+        resolveImportPathCache.set(cacheKey, null);
+        return null;
+    }
+}

package/dist/react/parse/createInlineUpdates.js

@@ -1,16 +1,12 @@
 import fs from 'node:fs';
 import { parse } from '@babel/parser';
-import traverseModule from '@babel/traverse';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
 import { hashSource } from 'generaltranslation/id';
-import { parseJSXElement } from '../jsx/utils/parseJsx.js';
+import { parseTranslationComponent } from '../jsx/utils/jsxParsing/parseJsx.js';
 import { parseStrings } from '../jsx/utils/parseStringFunction.js';
-import { extractImportName } from '../jsx/utils/parseAst.js';
 import { logError } from '../../console/logging.js';
-import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_TRANSLATION_HOOK, } from '../jsx/utils/constants.js';
 import { matchFiles } from '../../fs/matchFiles.js';
 import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
+import { getPathsAndAliases } from '../jsx/utils/getPathsAndAliases.js';
 export async function createInlineUpdates(pkg, validate, filePatterns, parsingOptions) {
     const updates = [];
     const errors = [];
@@ -30,75 +26,28 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
             logError(`Error parsing file ${file}: ${error}`);
             continue;
         }
-        const importAliases = {};
         // First pass: collect imports and process translation functions
-        const translationPaths = [];
-        traverse(ast, {
-            ImportDeclaration(path) {
-                if (path.node.source.value.startsWith(pkg)) {
-                    const importName = extractImportName(path.node, pkg, GT_TRANSLATION_FUNCS);
-                    for (const name of importName) {
-                        if (name.original === INLINE_TRANSLATION_HOOK ||
-                            name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
-                            name.original === INLINE_MESSAGE_HOOK ||
-                            name.original === INLINE_MESSAGE_HOOK_ASYNC ||
-                            name.original === MSG_TRANSLATION_HOOK) {
-                            translationPaths.push({
-                                localName: name.local,
-                                path,
-                                originalName: name.original,
-                            });
-                        }
-                        else {
-                            importAliases[name.local] = name.original;
-                        }
-                    }
-                }
-            },
-            VariableDeclarator(path) {
-                // Check if the init is a require call
-                if (path.node.init?.type === 'CallExpression' &&
-                    path.node.init.callee.type === 'Identifier' &&
-                    path.node.init.callee.name === 'require') {
-                    // Check if it's requiring our package
-                    const args = path.node.init.arguments;
-                    if (args.length === 1 &&
-                        args[0].type === 'StringLiteral' &&
-                        args[0].value.startsWith(pkg)) {
-                        const parentPath = path.parentPath;
-                        if (parentPath.isVariableDeclaration()) {
-                            const importName = extractImportName(parentPath.node, pkg, GT_TRANSLATION_FUNCS);
-                            for (const name of importName) {
-                                if (name.original === INLINE_TRANSLATION_HOOK ||
-                                    name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
-                                    name.original === INLINE_MESSAGE_HOOK ||
-                                    name.original === INLINE_MESSAGE_HOOK_ASYNC ||
-                                    name.original === MSG_TRANSLATION_HOOK) {
-                                    translationPaths.push({
-                                        localName: name.local,
-                                        path: parentPath,
-                                        originalName: name.original,
-                                    });
-                                }
-                                else {
-                                    importAliases[name.local] = name.original;
-                                }
-                            }
-                        }
-                    }
-                }
-            },
-        });
+        const { importAliases, inlineTranslationPaths, translationComponentPaths } = getPathsAndAliases(ast, pkg);
         // Process translation functions asynchronously
-        for (const { localName: name, originalName, path } of translationPaths) {
+        for (const { localName: name, originalName, path, } of inlineTranslationPaths) {
             parseStrings(name, originalName, path, updates, errors, warnings, file, parsingOptions);
         }
         // Parse <T> components
-        traverse(ast, {
-            JSXElement(path) {
-                parseJSXElement(importAliases, path.node, updates, errors, warnings, file);
-            },
-        });
+        for (const { localName, path } of translationComponentPaths) {
+            parseTranslationComponent({
+                importAliases: importAliases,
+                originalName: localName,
+                localName,
+                ast,
+                pkg,
+                path,
+                updates,
+                errors,
+                warnings,
+                file,
+                parsingOptions,
+            });
+        }
         // Extra validation (for Locadex)
         // Done in parseStrings() atm
         // if (validate) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.5.0-alpha.3",
+  "version": "2.5.1",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -93,7 +93,7 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "generaltranslation": "8.0.0-alpha.1"
+    "generaltranslation": "8.0.0"
   },
   "devDependencies": {
     "@babel/types": "^7.28.4",

package/dist/react/jsx/trimJsxStringChildren.d.ts

@@ -1,7 +0,0 @@
-export declare function trimJsxStringChild(child: string, index: number, childrenTypes: ('expression' | 'text' | 'element')[]): string;
-/**
- * Handles whitespace in children of a JSX element.
- * @param currentTree - The current tree to handle
- * @returns The processed tree with whitespace handled
- */
-export declare const handleChildrenWhitespace: (currentTree: any) => any;