gtx-cli 2.5.35 → 2.5.36

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

@@ -1,6 +1,6 @@
 import * as t from '@babel/types';
 import { isStaticExpression, isValidIcu } from '../evaluateJsx.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 { GT_ATTRIBUTES_WITH_SUGAR, MSG_TRANSLATION_FUNCTION, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } from './constants.js';
 import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, warnInvalidIcuSync, warnInvalidMaxCharsSync, } from '../../../console/index.js';
 import generateModule from '@babel/generator';
 import traverseModule from '@babel/traverse';
@@ -12,7 +12,10 @@ import pathModule from 'node:path';
 import { parse } from '@babel/parser';
 import { resolveImportPath } from './resolveImportPath.js';
 import { buildImportMap } from './buildImportMap.js';
+import { handleStaticExpression } from './parseDeclareStatic.js';
+import { nodeToStrings } from './parseString.js';
 import { isNumberLiteral } from './isNumberLiteral.js';
+import { indexVars } from 'generaltranslation/internal';
 /**
  * Cache for resolved import paths to avoid redundant I/O operations.
  * Key: `${currentFile}::${importPath}`
@@ -42,11 +45,62 @@ export function clearParsingCaches() {
  * - Metadata extraction from options object
  * - Error reporting for non-static expressions and template literals with expressions
  */
-function processTranslationCall(tPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu) {
+function processTranslationCall(tPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions) {
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.arguments.length > 0) {
         const arg = tPath.parent.arguments[0];
-        if (arg.type === 'StringLiteral' ||
+        // if (t.isExpression(arg)) {
+        if (!ignoreDynamicContent &&
+            t.isExpression(arg) &&
+            !isStaticExpression(arg).isStatic) {
+            const result = handleStaticExpression(arg, tPath, file, parsingOptions, errors);
+            if (result) {
+                const strings = nodeToStrings(result).map(indexVars);
+                if (!ignoreInvalidIcu) {
+                    for (const string of strings) {
+                        const { isValid, error } = isValidIcu(string);
+                        if (!isValid) {
+                            warnings.add(warnInvalidIcuSync(file, string, error ?? 'Unknown error', `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+                            return;
+                        }
+                    }
+                }
+                // 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 (GT_ATTRIBUTES_WITH_SUGAR.includes(attribute) &&
+                                t.isExpression(prop.value)) {
+                                const result = isStaticExpression(prop.value);
+                                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) {
+                                    // Map $id and $context to id and context
+                                    metadata[mapAttributeName(attribute)] = result.value;
+                                }
+                            }
+                        }
+                    });
+                }
+                for (const string of strings) {
+                    updates.push({
+                        dataFormat: 'ICU',
+                        source: string,
+                        metadata: { ...metadata },
+                    });
+                }
+                return;
+            }
+            // Nothing returned, push error
+            errors.push(warnNonStringSync(file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+            // ignore dynamic content flag is triggered, check strings are valid ICU
+        }
+        else if (arg.type === 'StringLiteral' ||
             (t.isTemplateLiteral(arg) && arg.expressions.length === 0)) {
             const source = arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;
             // Validate is ICU
@@ -71,9 +125,7 @@ function processTranslationCall(tPath, updates, errors, warnings, file, ignoreAd
                             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 != null &&
-                                !ignoreAdditionalData) {
+                            if (result.isStatic && result.value && !ignoreAdditionalData) {
                                 const mappedKey = mapAttributeName(attribute);
                                 if (attribute === '$maxChars') {
                                     if ((typeof result.value === 'string' &&
@@ -124,6 +176,7 @@ function processTranslationCall(tPath, updates, errors, warnings, file, ignoreAd
                 errors.push(warnNonStringSync(file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
             }
         }
+        // }
     }
 }
 /**
@@ -148,7 +201,7 @@ function extractParameterName(param) {
  * @param visited Set to track already visited variables to prevent infinite loops
  * @returns Array of all variable names that reference the original translation callback
  */
-function resolveVariableAliases(scope, variableName, visited = new Set()) {
+export function resolveVariableAliases(scope, variableName, visited = new Set()) {
     if (visited.has(variableName)) {
         return []; // Prevent infinite loops
     }
@@ -184,7 +237,7 @@ function handleFunctionCall(tPath, updates, errors, warnings, file, importMap, i
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.callee === tPath.node) {
         // Direct translation call: t('hello')
-        processTranslationCall(tPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu);
+        processTranslationCall(tPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
     }
     else if (tPath.parent.type === 'CallExpression' &&
         t.isExpression(tPath.node) &&
@@ -373,14 +426,14 @@ export function parseStrings(importName, originalName, path, updates, errors, wa
     const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
     for (const refPath of referencePaths) {
         // Handle msg() calls directly without variable assignment
-        if (originalName === MSG_TRANSLATION_HOOK) {
+        if (originalName === MSG_TRANSLATION_FUNCTION) {
             const ignoreAdditionalData = false;
             const ignoreDynamicContent = false;
             const ignoreInvalidIcu = 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, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu);
+                processTranslationCall(refPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
             }
             continue;
         }

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

@@ -0,0 +1,14 @@
+type StringNode = StringTextNode | StringSequenceNode | StringChoiceNode;
+type StringTextNode = {
+    type: 'text';
+    text: string;
+};
+type StringSequenceNode = {
+    type: 'sequence';
+    nodes: StringNode[];
+};
+type StringChoiceNode = {
+    type: 'choice';
+    nodes: StringNode[];
+};
+export type { StringNode, StringTextNode, StringSequenceNode, StringChoiceNode, };

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

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.5.35",
+  "version": "2.5.36",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -106,7 +106,7 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "generaltranslation": "8.1.3"
+    "generaltranslation": "8.1.4"
   },
   "devDependencies": {
     "@babel/types": "^7.28.4",