gtx-cli 1.2.30-alpha.29 → 1.2.30-alpha.31

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

@@ -1,2 +1,4 @@
 export declare const GT_TRANSLATION_FUNCS: string[];
 export declare const VARIABLE_COMPONENTS: string[];
+export declare const GT_ATTRIBUTES: string[];
+export declare function mapAttributeName(attrName: string): string;

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

@@ -12,3 +12,11 @@ export const GT_TRANSLATION_FUNCS = [
 ];
 // Valid variable components
 export const VARIABLE_COMPONENTS = ['Var', 'DateTime', 'Currency', 'Num'];
+export const GT_ATTRIBUTES = ['$id', '$context'];
+export function mapAttributeName(attrName) {
+    if (attrName === '$id')
+        return 'id';
+    if (attrName === '$context')
+        return 'context';
+    return attrName;
+}

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

@@ -7,7 +7,7 @@ import { warnHasUnwrappedExpressionSync, warnVariablePropSync, warnNestedTCompon
 import { isAcceptedPluralForm } from 'generaltranslation/internal';
 import { handleChildrenWhitespace } from '../trimJsxStringChildren.js';
 import { isStaticExpression } from '../evaluateJsx.js';
-import { VARIABLE_COMPONENTS } from './constants.js';
+import { GT_ATTRIBUTES, VARIABLE_COMPONENTS } from './constants.js';
 /**
  * Builds a JSX tree from a given node, recursively handling children.
  * @param node - The node to build the tree from
@@ -181,7 +181,7 @@ export function parseJSXElement(importAliases, node, updates, errors, file) {
                 const expr = attr.value.expression;
                 const code = generate(expr).code;
                 // Only check for static expressions on id and context props
-                if (attrName === 'id' || attrName === 'context') {
+                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}`));

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

@@ -1,6 +1,5 @@
 import { NodePath } from '@babel/traverse';
 import { Updates } from '../../../types/index.js';
-export declare const attributes: string[];
 /**
  * Main entry point for parsing translation strings from useGT() and getGT() calls.
  *

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

@@ -1,5 +1,6 @@
 import * as t from '@babel/types';
 import { isStaticExpression } from '../evaluateJsx.js';
+import { GT_ATTRIBUTES, mapAttributeName } from './constants.js';
 import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, } from '../../../console/index.js';
 import generateModule from '@babel/generator';
 import traverseModule from '@babel/traverse';
@@ -11,7 +12,6 @@ import path from 'node:path';
 import { parse } from '@babel/parser';
 import { createMatchPath, loadConfig } from 'tsconfig-paths';
 import * as resolve from 'resolve';
-export const attributes = ['id', 'context'];
 /**
  * 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.
@@ -37,13 +37,15 @@ function processTranslationCall(tPath, updates, errors, file) {
                     if (prop.type === 'ObjectProperty' &&
                         prop.key.type === 'Identifier') {
                         const attribute = prop.key.name;
-                        if (attributes.includes(attribute) && t.isExpression(prop.value)) {
+                        if (GT_ATTRIBUTES.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) {
-                                metadata[attribute] = result.value;
+                                // Map $id and $context to id and context
+                                metadata[mapAttributeName(attribute)] = result.value;
                             }
                         }
                     }

package/dist/react/parse/createDictionaryUpdates.js

@@ -44,7 +44,8 @@ export default async function createDictionaryUpdates(dictionaryPath, esbuildCon
     for (const id of Object.keys(dictionary)) {
         const { entry, metadata: props, // context, etc.
          } = getEntryAndMetadata(dictionary[id]);
-        const context = props?.context;
+        // Map $context to context
+        const context = props?.$context;
         const metadata = {
             id,
             ...(context && { context }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "1.2.30-alpha.29",
+  "version": "1.2.30-alpha.31",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -87,7 +87,7 @@
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.2",
-    "generaltranslation": "^7.0.0-alpha.29",
+    "generaltranslation": "^7.0.0-alpha.31",
     "open": "^10.1.1",
     "ora": "^8.2.0",
     "resolve": "^1.22.10",

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

@@ -1,12 +0,0 @@
-import { NodePath } from '@babel/traverse';
-import { Updates } from '../../../types/index.js';
-export declare const attributes: string[];
-/**
- * For the following example code:
- * const tx = useGT();
- * tx('string to translate', { id: 'exampleId', context: 'exampleContext' });
- *
- * 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.
- */
-export declare function parseStrings(importName: string, path: NodePath, updates: Updates, errors: string[], file: string): void;

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

@@ -1,77 +0,0 @@
-import * as t from '@babel/types';
-import { isStaticExpression } from '../evaluateJsx.js';
-import { warnNonStaticExpressionSync, warnTemplateLiteralSync, } from '../../../console/index.js';
-import generateModule from '@babel/generator';
-// Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
-export const attributes = ['id', 'context'];
-/**
- * For the following example code:
- * const tx = useGT();
- * tx('string to translate', { id: 'exampleId', context: 'exampleContext' });
- *
- * 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.
- */
-export function parseStrings(importName, path, updates, errors, file) {
-    path.scope.bindings[importName]?.referencePaths.forEach((refPath) => {
-        // 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 effectiveParent = parentPath?.node.type === 'AwaitExpression'
-                ? parentPath.parentPath
-                : parentPath;
-            if (effectiveParent &&
-                effectiveParent.node.type === 'VariableDeclarator' &&
-                effectiveParent.node.id.type === 'Identifier') {
-                const tFuncName = effectiveParent.node.id.name;
-                // Get the scope from the variable declaration
-                const variableScope = effectiveParent.scope;
-                variableScope.bindings[tFuncName]?.referencePaths.forEach((tPath) => {
-                    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;
-                            // 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 (attributes.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) {
-                                                metadata[attribute] = result.value;
-                                            }
-                                        }
-                                    }
-                                });
-                            }
-                            updates.push({
-                                dataFormat: 'ICU',
-                                source,
-                                metadata,
-                            });
-                        }
-                        else if (t.isTemplateLiteral(arg)) {
-                            // warn if template literal
-                            errors.push(warnTemplateLiteralSync(file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-                        }
-                    }
-                });
-            }
-        }
-    });
-}