gtx-cli 1.2.20 → 1.2.21

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 1.2.21
+
+### Patch Changes
+
+- [#324](https://github.com/generaltranslation/gt/pull/324) [`34a8c97`](https://github.com/generaltranslation/gt/commit/34a8c97a9d4c9efb3b441eecf0f7ea77ccc1ad7a) Thanks [@brian-lou](https://github.com/brian-lou)! - Add support for passing useGT and getGT function callback into other functions
+
 ## 1.2.20
 
 ### Patch Changes

package/dist/console/logging.js

@@ -32,6 +32,7 @@ exports.warnTemplateLiteral = warnTemplateLiteral;
 exports.warnTernary = warnTernary;
 const prompts_1 = require("@clack/prompts");
 const chalk_1 = __importDefault(require("chalk"));
+const packageJson_1 = require("../utils/packageJson");
 // Basic logging functions
 function logInfo(message) {
     prompts_1.log.info(message);
@@ -81,7 +82,10 @@ Y8,        88      88
   \`"Y88888P"       88       `));
 }
 function displayInitializingText() {
-    console.log(`\n${chalk_1.default.bold.blue('General Translation, Inc.')}\n${chalk_1.default.gray('https://generaltranslation.com/docs')}\n`);
+    const version = (0, packageJson_1.getCLIVersion)();
+    console.log(`\n${chalk_1.default.bold.blue('General Translation, Inc.')}
+${chalk_1.default.gray('https://generaltranslation.com/docs')}
+${chalk_1.default.gray(`CLI Version: ${version}\n`)}`);
 }
 function displayProjectId(projectId) {
     logMessage(chalk_1.default.gray(`Project ID: ${chalk_1.default.bold(projectId)}`));

package/dist/fs/getPackageResource.d.ts

@@ -0,0 +1 @@
+export declare function fromPackageRoot(relative: string): string;

package/dist/fs/getPackageResource.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromPackageRoot = fromPackageRoot;
+const node_path_1 = __importDefault(require("node:path"));
+function fromPackageRoot(relative) {
+    return node_path_1.default.resolve(__dirname, `../../`, relative);
+}

package/dist/react/data-_gt/addGTIdentifierToSyntaxTree.js

@@ -40,7 +40,7 @@ function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
                     key: (0, getVariableName_1.getVariableName)({ ...props, 'data-_gt': generaltranslation }, 'datetime'),
                 };
             }
-            else if (type === "" || type === "React.Fragment") {
+            else if (type === '' || type === 'React.Fragment') {
                 generaltranslation.transformation = 'fragment';
             }
             if (type === 'Plural') {

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

@@ -128,7 +128,9 @@ function buildJSXTree(importAliases, node, unwrappedExpressions, updates, errors
         if (elementIsVariable) {
             parseJSXElement(importAliases, element, updates, errors, file);
             return {
-                type: componentType,
+                // if componentType is undefined, use typeName
+                // Basically, if componentType is not a GT component, use typeName such as <div>
+                type: componentType ?? typeName,
                 props,
             };
         }
@@ -142,7 +144,9 @@ function buildJSXTree(importAliases, node, unwrappedExpressions, updates, errors
             props.children = children;
         }
         return {
-            type: componentType,
+            // if componentType is undefined, use typeName
+            // Basically, if componentType is not a GT component, use typeName such as <div>
+            type: componentType ?? typeName,
             props,
         };
     }

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

@@ -2,11 +2,16 @@ import { NodePath } from '@babel/traverse';
 import { Updates } from '../../../types';
 export declare const attributes: string[];
 /**
- * For the following example code:
- * const t = useGT();
- * t('string to translate', { id: 'exampleId', context: 'exampleContext' });
+ * Main entry point for parsing translation strings from useGT() and getGT() calls.
  *
- * This function will find all call expressions of useGT(), then find all call expressions
- * of the subsequent tx() calls, and append the content and metadata to the updates array.
+ * Supports complex patterns including:
+ * 1. Direct calls: const t = useGT(); t('hello');
+ * 2. Function parameters: const t = useGT(); getInfo(t); where getInfo uses t() internally
+ * 3. Cross-file function calls: imported functions that receive t as a parameter
+ *
+ * Example flow:
+ * - const t = useGT();
+ * - const { home } = getInfo(t); // getInfo is imported from './constants'
+ * - This will parse constants.ts to find t() calls within getInfo function
  */
 export declare function parseStrings(importName: string, path: NodePath, updates: Updates, errors: string[], file: string): void;

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

@@ -43,17 +43,227 @@ const t = __importStar(require("@babel/types"));
 const evaluateJsx_1 = require("../evaluateJsx");
 const console_1 = require("../../../console");
 const generator_1 = __importDefault(require("@babel/generator"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const tsconfig_paths_1 = require("tsconfig-paths");
+const resolve = __importStar(require("resolve"));
 exports.attributes = ['id', 'context'];
 /**
- * For the following example code:
- * const t = useGT();
- * t('string to translate', { id: 'exampleId', context: 'exampleContext' });
+ * Processes a single translation function call (e.g., t('hello world', { id: 'greeting' })).
+ * Extracts the translatable string content and metadata, then adds it to the updates array.
  *
- * This function will find all call expressions of useGT(), then find all call expressions
- * of the subsequent tx() calls, and append the content and metadata to the updates array.
+ * Handles:
+ * - String literals: t('hello')
+ * - Template literals without expressions: t(`hello`)
+ * - Metadata extraction from options object
+ * - Error reporting for non-static expressions and template literals with expressions
+ */
+function processTranslationCall(tPath, updates, errors, file) {
+    if (tPath.parent.type === 'CallExpression' &&
+        tPath.parent.arguments.length > 0) {
+        const arg = tPath.parent.arguments[0];
+        if (arg.type === 'StringLiteral' ||
+            (t.isTemplateLiteral(arg) && arg.expressions.length === 0)) {
+            const source = arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;
+            // split the string into content (same as runtime behavior)
+            const content = (0, generaltranslation_1.splitStringToContent)(source);
+            // get metadata and id from options
+            const options = tPath.parent.arguments[1];
+            const metadata = {};
+            if (options && options.type === 'ObjectExpression') {
+                options.properties.forEach((prop) => {
+                    if (prop.type === 'ObjectProperty' &&
+                        prop.key.type === 'Identifier') {
+                        const attribute = prop.key.name;
+                        if (exports.attributes.includes(attribute) && t.isExpression(prop.value)) {
+                            const result = (0, evaluateJsx_1.isStaticExpression)(prop.value);
+                            if (!result.isStatic) {
+                                errors.push((0, console_1.warnNonStaticExpressionSync)(file, attribute, (0, generator_1.default)(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+                            }
+                            if (result.isStatic && result.value) {
+                                metadata[attribute] = result.value;
+                            }
+                        }
+                    }
+                });
+            }
+            updates.push({
+                dataFormat: 'JSX',
+                source: content,
+                metadata,
+            });
+        }
+        else if (t.isTemplateLiteral(arg)) {
+            // warn if template literal
+            errors.push((0, console_1.warnTemplateLiteralSync)(file, (0, generator_1.default)(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+        }
+        else {
+            errors.push((0, console_1.warnNonStringSync)(file, (0, generator_1.default)(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+        }
+    }
+}
+/**
+ * Finds all usages of a function parameter within a function's scope and processes
+ * any translation calls made with that parameter.
+ *
+ * Example: In function getInfo(t) { return t('hello'); }, this finds the t('hello') call.
+ */
+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;
+        const binding = functionScope.bindings[parameterName];
+        if (binding) {
+            binding.referencePaths.forEach((refPath) => {
+                processTranslationCall(refPath, updates, errors, file);
+            });
+        }
+    }
+}
+/**
+ * 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) {
+    const basedir = node_path_1.default.dirname(currentFile);
+    const extensions = ['.tsx', '.ts', '.jsx', '.js'];
+    // 1. Try tsconfig-paths resolution first (handles TypeScript path mapping)
+    const tsConfigResult = (0, tsconfig_paths_1.loadConfig)(basedir);
+    if (tsConfigResult.resultType === 'success') {
+        const matchPath = (0, tsconfig_paths_1.createMatchPath)(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, ['main', 'module', 'browser']);
+        // First try without any extension
+        let tsResolved = matchPath(importPath);
+        if (tsResolved && node_fs_1.default.existsSync(tsResolved)) {
+            return tsResolved;
+        }
+        // Then try with each extension
+        for (const ext of extensions) {
+            tsResolved = matchPath(importPath + ext);
+            if (tsResolved && node_fs_1.default.existsSync(tsResolved)) {
+                return tsResolved;
+            }
+            // Also try the resolved path with extension
+            tsResolved = matchPath(importPath);
+            if (tsResolved) {
+                const resolvedWithExt = tsResolved + ext;
+                if (node_fs_1.default.existsSync(resolvedWithExt)) {
+                    return resolvedWithExt;
+                }
+            }
+        }
+    }
+    // 2. Fallback to Node.js resolution (handles relative paths and node_modules)
+    try {
+        return resolve.sync(importPath, { basedir, extensions });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Searches for a specific function in a file and analyzes how a particular parameter
+ * (at argIndex position) is used within that function for translation calls.
+ *
+ * Handles multiple function declaration patterns:
+ * - function getInfo(t) { ... }
+ * - export function getInfo(t) { ... }
+ * - const getInfo = (t) => { ... }
+ */
+function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
+    try {
+        const code = node_fs_1.default.readFileSync(filePath, 'utf8');
+        const ast = (0, parser_1.parse)(code, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript'],
+        });
+        (0, traverse_1.default)(ast, {
+            // Handle function declarations: function getInfo(t) { ... }
+            FunctionDeclaration(path) {
+                if (path.node.id?.name === functionName &&
+                    path.node.params.length > argIndex) {
+                    const param = path.node.params[argIndex];
+                    if (t.isIdentifier(param)) {
+                        findFunctionParameterUsage(path, param.name, updates, errors, filePath);
+                    }
+                }
+            },
+            // Handle exported function declarations: export function getInfo(t) { ... }
+            ExportNamedDeclaration(path) {
+                if (path.node.declaration &&
+                    t.isFunctionDeclaration(path.node.declaration)) {
+                    const func = path.node.declaration;
+                    if (func.id?.name === functionName && func.params.length > argIndex) {
+                        const param = func.params[argIndex];
+                        if (t.isIdentifier(param)) {
+                            findFunctionParameterUsage(path.get('declaration'), param.name, updates, errors, filePath);
+                        }
+                    }
+                }
+            },
+            // Handle variable declarations: const getInfo = (t) => { ... }
+            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)) &&
+                    path.node.init.params.length > argIndex) {
+                    const param = path.node.init.params[argIndex];
+                    if (t.isIdentifier(param)) {
+                        const initPath = path.get('init');
+                        findFunctionParameterUsage(initPath, param.name, updates, errors, filePath);
+                    }
+                }
+            },
+        });
+    }
+    catch {
+        // Silently skip files that can't be parsed or accessed
+    }
+}
+/**
+ * Main entry point for parsing translation strings from useGT() and getGT() calls.
+ *
+ * Supports complex patterns including:
+ * 1. Direct calls: const t = useGT(); t('hello');
+ * 2. Function parameters: const t = useGT(); getInfo(t); where getInfo uses t() internally
+ * 3. Cross-file function calls: imported functions that receive t as a parameter
+ *
+ * Example flow:
+ * - const t = useGT();
+ * - const { home } = getInfo(t); // getInfo is imported from './constants'
+ * - This will parse constants.ts to find t() calls within getInfo function
  */
 function parseStrings(importName, path, updates, errors, file) {
-    path.scope.bindings[importName]?.referencePaths.forEach((refPath) => {
+    // First, collect all imports in this file to track cross-file function calls
+    const importMap = new Map(); // functionName -> importPath
+    path.scope.getProgramParent().path.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);
+                    }
+                });
+            }
+        },
+    });
+    const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
+    for (const refPath of referencePaths) {
         // Find call expressions of useGT() / await getGT()
         const callExpr = refPath.findParent((p) => p.isCallExpression());
         if (callExpr) {
@@ -68,54 +278,44 @@ function parseStrings(importName, path, updates, errors, file) {
                 const tFuncName = effectiveParent.node.id.name;
                 // Get the scope from the variable declaration
                 const variableScope = effectiveParent.scope;
-                variableScope.bindings[tFuncName]?.referencePaths.forEach((tPath) => {
+                const tReferencePaths = variableScope.bindings[tFuncName]?.referencePaths || [];
+                for (const tPath of tReferencePaths) {
+                    // Check if this is a direct call to the translation function
                     if (tPath.parent.type === 'CallExpression' &&
-                        tPath.parent.arguments.length > 0) {
-                        const arg = tPath.parent.arguments[0];
-                        if (arg.type === 'StringLiteral' ||
-                            (t.isTemplateLiteral(arg) && arg.expressions.length === 0)) {
-                            const source = arg.type === 'StringLiteral'
-                                ? arg.value
-                                : arg.quasis[0].value.raw;
-                            // split the string into content (same as runtime behavior)
-                            const content = (0, generaltranslation_1.splitStringToContent)(source);
-                            // get metadata and id from options
-                            const options = tPath.parent.arguments[1];
-                            const metadata = {};
-                            if (options && options.type === 'ObjectExpression') {
-                                options.properties.forEach((prop) => {
-                                    if (prop.type === 'ObjectProperty' &&
-                                        prop.key.type === 'Identifier') {
-                                        const attribute = prop.key.name;
-                                        if (exports.attributes.includes(attribute) &&
-                                            t.isExpression(prop.value)) {
-                                            const result = (0, evaluateJsx_1.isStaticExpression)(prop.value);
-                                            if (!result.isStatic) {
-                                                errors.push((0, console_1.warnNonStaticExpressionSync)(file, attribute, (0, generator_1.default)(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                                            }
-                                            if (result.isStatic && result.value) {
-                                                metadata[attribute] = result.value;
-                                            }
-                                        }
-                                    }
-                                });
+                        tPath.parent.callee === tPath.node) {
+                        processTranslationCall(tPath, updates, errors, file);
+                    }
+                    // Check if this is being passed as an argument to another function
+                    else if (tPath.parent.type === 'CallExpression' &&
+                        t.isExpression(tPath.node) &&
+                        tPath.parent.arguments.includes(tPath.node)) {
+                        // Find which parameter position this is
+                        const argIndex = tPath.parent.arguments.indexOf(tPath.node);
+                        // Try to find the function definition being called
+                        const callee = tPath.parent.callee;
+                        if (t.isIdentifier(callee)) {
+                            // Look for function declarations or function expressions with this name
+                            const calleeBinding = tPath.scope.getBinding(callee.name);
+                            if (calleeBinding && calleeBinding.path.isFunction()) {
+                                const functionPath = calleeBinding.path;
+                                const params = functionPath.node.params;
+                                if (params[argIndex] && t.isIdentifier(params[argIndex])) {
+                                    const paramName = params[argIndex].name;
+                                    findFunctionParameterUsage(functionPath, paramName, 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);
+                                }
                             }
-                            updates.push({
-                                dataFormat: 'JSX',
-                                source: content,
-                                metadata,
-                            });
-                        }
-                        else if (t.isTemplateLiteral(arg)) {
-                            // warn if template literal
-                            errors.push((0, console_1.warnTemplateLiteralSync)(file, (0, generator_1.default)(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-                        }
-                        else {
-                            errors.push((0, console_1.warnNonStringSync)(file, (0, generator_1.default)(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
                         }
                     }
-                });
+                }
             }
         }
-    });
+    }
 }

package/dist/react/parse/createInlineUpdates.js

@@ -72,14 +72,15 @@ async function createInlineUpdates(options, pkg) {
             'Plural',
         ];
         const importAliases = {};
-        // handle imports & alias & handle string functions
+        // First pass: collect imports and process translation functions
+        const translationPaths = [];
         (0, traverse_1.default)(ast, {
             ImportDeclaration(path) {
                 if (path.node.source.value.startsWith(pkg)) {
                     const importName = (0, parseAst_1.extractImportName)(path.node, pkg, translationFuncs);
                     for (const name of importName) {
                         if (name.original === 'useGT' || name.original === 'getGT') {
-                            (0, parseStringFunction_1.parseStrings)(name.local, path, updates, errors, file);
+                            translationPaths.push({ name: name.local, path });
                         }
                         else {
                             importAliases[name.local] = name.original;
@@ -102,7 +103,7 @@ async function createInlineUpdates(options, pkg) {
                             const importName = (0, parseAst_1.extractImportName)(parentPath.node, pkg, translationFuncs);
                             for (const name of importName) {
                                 if (name.original === 'useGT' || name.original === 'getGT') {
-                                    (0, parseStringFunction_1.parseStrings)(name.local, parentPath, updates, errors, file);
+                                    translationPaths.push({ name: name.local, path: parentPath });
                                 }
                                 else {
                                     importAliases[name.local] = name.original;
@@ -113,6 +114,10 @@ async function createInlineUpdates(options, pkg) {
                 }
             },
         });
+        // Process translation functions asynchronously
+        for (const { name, path } of translationPaths) {
+            (0, parseStringFunction_1.parseStrings)(name, path, updates, errors, file);
+        }
         // Parse <T> components
         (0, traverse_1.default)(ast, {
             JSXElement(path) {

package/dist/utils/packageJson.d.ts

@@ -1,5 +1,6 @@
 export declare function searchForPackageJson(): Promise<Record<string, any> | null>;
 export declare function getPackageJson(): Promise<Record<string, any>>;
+export declare function getCLIVersion(): string;
 export declare function updatePackageJson(packageJson: Record<string, any>): Promise<void>;
 export declare function isPackageInstalled(packageName: string, packageJson: Record<string, any>, asDevDependency?: boolean, checkBoth?: boolean): boolean;
 export declare function getPackageVersion(packageName: string, packageJson: Record<string, any>): string | undefined;

package/dist/utils/packageJson.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.searchForPackageJson = searchForPackageJson;
 exports.getPackageJson = getPackageJson;
+exports.getCLIVersion = getCLIVersion;
 exports.updatePackageJson = updatePackageJson;
 exports.isPackageInstalled = isPackageInstalled;
 exports.getPackageVersion = getPackageVersion;
@@ -13,6 +14,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const console_2 = require("../console");
+const getPackageResource_1 = require("../fs/getPackageResource");
 // search for package.json such that we can run init in non-js projects
 async function searchForPackageJson() {
     // Get the current working directory (where the CLI is being run)
@@ -45,6 +47,18 @@ async function getPackageJson() {
         process.exit(1);
     }
 }
+function getCLIVersion() {
+    const packageJsonPath = (0, getPackageResource_1.fromPackageRoot)('package.json');
+    if (!node_fs_1.default.existsSync(packageJsonPath)) {
+        return 'unknown';
+    }
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, 'utf8')).version;
+    }
+    catch (error) {
+        return 'unknown';
+    }
+}
 async function updatePackageJson(packageJson) {
     try {
         await node_fs_1.default.promises.writeFile(node_path_1.default.join(process.cwd(), 'package.json'), JSON.stringify(packageJson, null, 2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "1.2.20",
+  "version": "1.2.21",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -81,7 +81,9 @@
     "form-data": "^4.0.2",
     "generaltranslation": "^6.2.9",
     "open": "^10.1.1",
-    "ora": "^8.2.0"
+    "ora": "^8.2.0",
+    "resolve": "^1.22.10",
+    "tsconfig-paths": "^4.2.0"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
@@ -91,6 +93,7 @@
     "@types/mock-require": "^2.0.3",
     "@types/node": "^22.5.1",
     "@types/react": "^18.3.4",
+    "@types/resolve": "^1.20.2",
     "eslint": "^9.20.0",
     "esm": "^3.2.25",
     "prettier": "^3.4.2",