gtx-cli 2.1.8 → 2.1.9

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.1.9
+
+### Patch Changes
+
+- [#604](https://github.com/generaltranslation/gt/pull/604) [`43c6a76`](https://github.com/generaltranslation/gt/commit/43c6a76be3d3be420e892b86188ef41c45ae8ffe) Thanks [@archie-mckenzie](https://github.com/archie-mckenzie)! - Refactored useGT and useMessages in order to make useMessages function like an unlintable useGT
+
+## 2.1.8
+
+### Patch Changes
+
+- [#599](https://github.com/generaltranslation/gt/pull/599) [`5950592`](https://github.com/generaltranslation/gt/commit/5950592ca44197915216ec5c8e26f9714cb4f55c) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: msg() function
+
 ## 2.1.8
 
 ### Patch Changes

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

@@ -1,3 +1,8 @@
+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 INLINE_MESSAGE_HOOK = "useMessages";
+export declare const INLINE_MESSAGE_HOOK_ASYNC = "getMessages";
 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,7 +1,15 @@
+export const MSG_TRANSLATION_HOOK = 'msg';
+export const INLINE_TRANSLATION_HOOK = 'useGT';
+export const INLINE_TRANSLATION_HOOK_ASYNC = 'getGT';
+export const INLINE_MESSAGE_HOOK = 'useMessages';
+export const INLINE_MESSAGE_HOOK_ASYNC = 'getMessages';
 // GT translation functions
 export const GT_TRANSLATION_FUNCS = [
-    'useGT',
-    'getGT',
+    INLINE_TRANSLATION_HOOK,
+    INLINE_TRANSLATION_HOOK_ASYNC,
+    INLINE_MESSAGE_HOOK,
+    INLINE_MESSAGE_HOOK_ASYNC,
+    MSG_TRANSLATION_HOOK,
     '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, mapAttributeName } from './constants.js';
+import { GT_ATTRIBUTES_WITH_SUGAR, MSG_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } 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) {
+function processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent) {
     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) {
                             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) {
+                            if (result.isStatic && result.value && !ignoreAdditionalData) {
                                 // Map $id and $context to id and context
                                 metadata[mapAttributeName(attribute)] = result.value;
                             }
@@ -59,10 +59,14 @@ function processTranslationCall(tPath, updates, errors, file) {
         }
         else if (t.isTemplateLiteral(arg)) {
             // warn if template literal
-            errors.push(warnTemplateLiteralSync(file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+            if (!ignoreDynamicContent) {
+                errors.push(warnTemplateLiteralSync(file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+            }
         }
         else {
-            errors.push(warnNonStringSync(file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+            if (!ignoreDynamicContent) {
+                errors.push(warnNonStringSync(file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+            }
         }
     }
 }
@@ -145,11 +149,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) {
+function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent) {
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.callee === tPath.node) {
         // Direct translation call: t('hello')
-        processTranslationCall(tPath, updates, errors, file);
+        processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent);
     }
     else if (tPath.parent.type === 'CallExpression' &&
         t.isExpression(tPath.node) &&
@@ -161,7 +165,7 @@ function handleFunctionCall(tPath, updates, errors, file, importMap) {
             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);
+                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent);
             }
             // Handle arrow functions assigned to variables: const getData = (t) => {...}
             else if (calleeBinding &&
@@ -170,14 +174,14 @@ function handleFunctionCall(tPath, updates, errors, file, importMap) {
                 (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);
+                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent);
             }
             // 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);
+                    findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent);
                 }
             }
         }
@@ -188,12 +192,12 @@ function handleFunctionCall(tPath, updates, errors, file, importMap) {
  * 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) {
+function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent) {
     if (functionNode.params.length > argIndex) {
         const param = functionNode.params[argIndex];
         const paramName = extractParameterName(param);
         if (paramName) {
-            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath);
+            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent);
         }
     }
 }
@@ -205,7 +209,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) {
+function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent) {
     // Look for the function body and find all usages of the parameter
     if (functionPath.isFunction()) {
         const functionScope = functionPath.scope;
@@ -220,7 +224,7 @@ function findFunctionParameterUsage(functionPath, parameterName, updates, errors
             const binding = functionScope.bindings[name];
             if (binding) {
                 binding.referencePaths.forEach((refPath) => {
-                    handleFunctionCall(refPath, updates, errors, file, importMap);
+                    handleFunctionCall(refPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent);
                 });
             }
         });
@@ -299,7 +303,7 @@ function resolveImportPath(currentFile, importPath) {
  * - export function getInfo(t) { ... }
  * - const getInfo = (t) => { ... }
  */
-function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
+function findFunctionInFile(filePath, functionName, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent) {
     try {
         const code = fs.readFileSync(filePath, 'utf8');
         const ast = parse(code, {
@@ -310,7 +314,7 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
             // Handle function declarations: function getInfo(t) { ... }
             FunctionDeclaration(path) {
                 if (path.node.id?.name === functionName) {
-                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath);
+                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent);
                 }
             },
             // Handle variable declarations: const getInfo = (t) => { ... }
@@ -321,7 +325,7 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
                     (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);
+                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent);
                 }
             },
         });
@@ -348,21 +352,40 @@ 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) {
-        // Find call expressions of useGT() / await getGT()
+        // Handle msg() calls directly without variable assignment
+        if (originalName === MSG_TRANSLATION_HOOK) {
+            const ignoreAdditionalData = false;
+            const ignoreDynamicContent = false;
+            // 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, ignoreDynamicContent);
+            }
+            continue;
+        }
+        // Handle useGT(), getGT(), useMessages(), and getMessages() calls that need variable assignment
         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 === 'useGT') {
+            if (asyncScope &&
+                (originalName === INLINE_TRANSLATION_HOOK ||
+                    originalName === INLINE_MESSAGE_HOOK)) {
                 errors.push(warnAsyncUseGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
                 return;
             }
-            else if (!asyncScope && originalName === 'getGT') {
+            else if (!asyncScope &&
+                (originalName === INLINE_TRANSLATION_HOOK_ASYNC ||
+                    originalName === INLINE_MESSAGE_HOOK_ASYNC)) {
                 errors.push(warnSyncGetGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
                 return;
             }
+            const isMessageHook = originalName === INLINE_MESSAGE_HOOK ||
+                originalName === INLINE_MESSAGE_HOOK_ASYNC;
+            const ignoreAdditionalData = isMessageHook;
+            const ignoreDynamicContent = isMessageHook;
             const effectiveParent = parentPath?.node.type === 'AwaitExpression'
                 ? parentPath.parentPath
                 : parentPath;
@@ -372,10 +395,16 @@ 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;
-                const tReferencePaths = variableScope.bindings[tFuncName]?.referencePaths || [];
-                for (const tPath of tReferencePaths) {
-                    handleFunctionCall(tPath, updates, errors, file, importMap);
-                }
+                // 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, ignoreDynamicContent);
+                    }
+                });
             }
         }
     }

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

@@ -1,4 +1,5 @@
 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)
@@ -12,13 +13,13 @@ export function validateStringFunction(localImportName, path, updates, errors, f
                 callPath.node.callee.name === localImportName) {
                 // Check the function scope
                 const functionScope = callPath.getFunctionParent();
-                if (originalImportName === 'useGT') {
+                if (originalImportName === INLINE_TRANSLATION_HOOK) {
                     // 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 === 'getGT') {
+                else if (originalImportName === INLINE_TRANSLATION_HOOK_ASYNC) {
                     // 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 } from '../jsx/utils/constants.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';
 export async function createInlineUpdates(pkg, validate, filePatterns) {
@@ -38,7 +38,11 @@ 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 === 'useGT' || name.original === 'getGT') {
+                        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,
@@ -65,7 +69,11 @@ 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 === 'useGT' || name.original === 'getGT') {
+                                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,

package/package.json

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