gtx-cli 2.1.8-alpha.1 → 2.1.8

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

@@ -1,6 +1,3 @@
-export declare const MSG_TRANSLATION_HOOK = "msg";
-export declare const INLINE_TRANSLATION_HOOK = "useGT";
-export declare const INLINE_TRANSLATION_HOOK_ASYNC = "getGT";
 export declare const GT_TRANSLATION_FUNCS: string[];
 export declare const VARIABLE_COMPONENTS: string[];
 export declare const GT_ATTRIBUTES_WITH_SUGAR: string[];

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

@@ -1,11 +1,7 @@
-export const MSG_TRANSLATION_HOOK = 'msg';
-export const INLINE_TRANSLATION_HOOK = 'useGT';
-export const INLINE_TRANSLATION_HOOK_ASYNC = 'getGT';
 // GT translation functions
 export const GT_TRANSLATION_FUNCS = [
-    INLINE_TRANSLATION_HOOK,
-    INLINE_TRANSLATION_HOOK_ASYNC,
-    MSG_TRANSLATION_HOOK,
+    'useGT',
+    'getGT',
     'T',
     'Var',
     'DateTime',

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

@@ -1,6 +1,6 @@
 import * as t from '@babel/types';
 import { isStaticExpression } from '../evaluateJsx.js';
-import { GT_ATTRIBUTES_WITH_SUGAR, MSG_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, } from './constants.js';
+import { GT_ATTRIBUTES_WITH_SUGAR, mapAttributeName } from './constants.js';
 import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, } from '../../../console/index.js';
 import generateModule from '@babel/generator';
 import traverseModule from '@babel/traverse';
@@ -22,7 +22,7 @@ import resolve from 'resolve';
  * - Metadata extraction from options object
  * - Error reporting for non-static expressions and template literals with expressions
  */
-function processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData) {
+function processTranslationCall(tPath, updates, errors, file) {
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.arguments.length > 0) {
         const arg = tPath.parent.arguments[0];
@@ -43,7 +43,7 @@ function processTranslationCall(tPath, updates, errors, file, ignoreAdditionalDa
                             if (!result.isStatic) {
                                 errors.push(warnNonStaticExpressionSync(file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
                             }
-                            if (result.isStatic && result.value && !ignoreAdditionalData) {
+                            if (result.isStatic && result.value) {
                                 // Map $id and $context to id and context
                                 metadata[mapAttributeName(attribute)] = result.value;
                             }
@@ -145,11 +145,11 @@ function resolveVariableAliases(scope, variableName, visited = new Set()) {
  * This covers both direct translation calls (t('hello')) and prop drilling
  * where the translation callback is passed to other functions (getData(t)).
  */
-function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData) {
+function handleFunctionCall(tPath, updates, errors, file, importMap) {
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.callee === tPath.node) {
         // Direct translation call: t('hello')
-        processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData);
+        processTranslationCall(tPath, updates, errors, file);
     }
     else if (tPath.parent.type === 'CallExpression' &&
         t.isExpression(tPath.node) &&
@@ -161,7 +161,7 @@ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAddit
             const calleeBinding = tPath.scope.getBinding(callee.name);
             if (calleeBinding && calleeBinding.path.isFunction()) {
                 const functionPath = calleeBinding.path;
-                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file, ignoreAdditionalData);
+                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file);
             }
             // Handle arrow functions assigned to variables: const getData = (t) => {...}
             else if (calleeBinding &&
@@ -170,14 +170,14 @@ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAddit
                 (t.isArrowFunctionExpression(calleeBinding.path.node.init) ||
                     t.isFunctionExpression(calleeBinding.path.node.init))) {
                 const initPath = calleeBinding.path.get('init');
-                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file, ignoreAdditionalData);
+                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file);
             }
             // 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);
                 if (resolvedPath) {
-                    findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, ignoreAdditionalData);
+                    findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors);
                 }
             }
         }
@@ -188,12 +188,12 @@ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAddit
  * Validates the function has enough parameters and traces how the translation callback
  * is used within that function's body.
  */
-function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath, ignoreAdditionalData) {
+function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath) {
     if (functionNode.params.length > argIndex) {
         const param = functionNode.params[argIndex];
         const paramName = extractParameterName(param);
         if (paramName) {
-            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath, ignoreAdditionalData);
+            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath);
         }
     }
 }
@@ -205,7 +205,7 @@ function processFunctionIfMatches(_functionName, argIndex, functionNode, functio
  * Example: In function getInfo(t) { return t('hello'); }, this finds the t('hello') call.
  * Example: In function getData(t) { return getFooter(t); }, this finds and traces into getFooter.
  */
-function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file, ignoreAdditionalData) {
+function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file) {
     // Look for the function body and find all usages of the parameter
     if (functionPath.isFunction()) {
         const functionScope = functionPath.scope;
@@ -220,7 +220,7 @@ function findFunctionParameterUsage(functionPath, parameterName, updates, errors
             const binding = functionScope.bindings[name];
             if (binding) {
                 binding.referencePaths.forEach((refPath) => {
-                    handleFunctionCall(refPath, updates, errors, file, importMap, ignoreAdditionalData);
+                    handleFunctionCall(refPath, updates, errors, file, importMap);
                 });
             }
         });
@@ -299,7 +299,7 @@ function resolveImportPath(currentFile, importPath) {
  * - export function getInfo(t) { ... }
  * - const getInfo = (t) => { ... }
  */
-function findFunctionInFile(filePath, functionName, argIndex, updates, errors, ignoreAdditionalData) {
+function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
     try {
         const code = fs.readFileSync(filePath, 'utf8');
         const ast = parse(code, {
@@ -310,7 +310,7 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors, i
             // Handle function declarations: function getInfo(t) { ... }
             FunctionDeclaration(path) {
                 if (path.node.id?.name === functionName) {
-                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath, ignoreAdditionalData);
+                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath);
                 }
             },
             // Handle variable declarations: const getInfo = (t) => { ... }
@@ -321,7 +321,7 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors, i
                     (t.isArrowFunctionExpression(path.node.init) ||
                         t.isFunctionExpression(path.node.init))) {
                     const initPath = path.get('init');
-                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath, ignoreAdditionalData);
+                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath);
                 }
             },
         });
@@ -348,33 +348,21 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
     const importMap = buildImportMap(path.scope.getProgramParent().path);
     const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
     for (const refPath of referencePaths) {
-        // Handle msg() calls directly without variable assignment
-        if (originalName === MSG_TRANSLATION_HOOK) {
-            const ignoreAdditionalData = true;
-            // Check if this is a direct call to msg('string')
-            if (refPath.parent.type === 'CallExpression' &&
-                refPath.parent.callee === refPath.node) {
-                processTranslationCall(refPath, updates, errors, file, ignoreAdditionalData);
-            }
-            continue;
-        }
-        // Handle useGT() and getGT() calls that need variable assignment
+        // Find call expressions of useGT() / await getGT()
         const callExpr = refPath.findParent((p) => p.isCallExpression());
         if (callExpr) {
             // Get the parent, handling both await and non-await cases
             const parentPath = callExpr.parentPath;
             const parentFunction = refPath.getFunctionParent();
             const asyncScope = parentFunction?.node.async;
-            if (asyncScope && originalName === INLINE_TRANSLATION_HOOK) {
+            if (asyncScope && originalName === 'useGT') {
                 errors.push(warnAsyncUseGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
                 return;
             }
-            else if (!asyncScope &&
-                originalName === INLINE_TRANSLATION_HOOK_ASYNC) {
+            else if (!asyncScope && originalName === 'getGT') {
                 errors.push(warnSyncGetGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
                 return;
             }
-            const ignoreAdditionalData = false;
             const effectiveParent = parentPath?.node.type === 'AwaitExpression'
                 ? parentPath.parentPath
                 : parentPath;
@@ -384,16 +372,10 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
                 const tFuncName = effectiveParent.node.id.name;
                 // Get the scope from the variable declaration
                 const variableScope = effectiveParent.scope;
-                // Resolve all aliases of the translation function
-                // Example: translate -> [translate, t, a, b] for const t = translate; const a = t; const b = a;
-                const allTranslationNames = resolveVariableAliases(variableScope, tFuncName);
-                // Process references for all translation function names and their aliases
-                allTranslationNames.forEach((name) => {
-                    const tReferencePaths = variableScope.bindings[name]?.referencePaths || [];
-                    for (const tPath of tReferencePaths) {
-                        handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData);
-                    }
-                });
+                const tReferencePaths = variableScope.bindings[tFuncName]?.referencePaths || [];
+                for (const tPath of tReferencePaths) {
+                    handleFunctionCall(tPath, updates, errors, file, importMap);
+                }
             }
         }
     }

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

@@ -1,5 +1,4 @@
 import { warnAsyncUseGT, warnSyncGetGT } from '../../../console/index.js';
-import { INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, } from './constants.js';
 /**
  * Validate useGT() / await getGT() calls
  * 1. Validates that the call does not violate the rules of React (no hooks in async functions)
@@ -13,13 +12,13 @@ export function validateStringFunction(localImportName, path, updates, errors, f
                 callPath.node.callee.name === localImportName) {
                 // Check the function scope
                 const functionScope = callPath.getFunctionParent();
-                if (originalImportName === INLINE_TRANSLATION_HOOK) {
+                if (originalImportName === 'useGT') {
                     // useGT should NOT be in an async function
                     if (functionScope && functionScope.node.async) {
                         errors.push(warnAsyncUseGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));
                     }
                 }
-                else if (originalImportName === INLINE_TRANSLATION_HOOK_ASYNC) {
+                else if (originalImportName === 'getGT') {
                     // getGT should be in an async function
                     if (!functionScope || !functionScope.node.async) {
                         errors.push(warnSyncGetGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));

package/dist/react/parse/createInlineUpdates.js

@@ -8,7 +8,7 @@ import { parseJSXElement } from '../jsx/utils/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, MSG_TRANSLATION_HOOK, } from '../jsx/utils/constants.js';
+import { GT_TRANSLATION_FUNCS } from '../jsx/utils/constants.js';
 import { matchFiles } from '../../fs/matchFiles.js';
 import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
 export async function createInlineUpdates(pkg, validate, filePatterns) {
@@ -38,9 +38,7 @@ export async function createInlineUpdates(pkg, validate, filePatterns) {
                 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 === MSG_TRANSLATION_HOOK) {
+                        if (name.original === 'useGT' || name.original === 'getGT') {
                             translationPaths.push({
                                 localName: name.local,
                                 path,
@@ -67,9 +65,7 @@ export async function createInlineUpdates(pkg, validate, filePatterns) {
                         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 === MSG_TRANSLATION_HOOK) {
+                                if (name.original === 'useGT' || name.original === 'getGT') {
                                     translationPaths.push({
                                         localName: name.local,
                                         path: parentPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.1.8-alpha.1",
+  "version": "2.1.8",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [