gtx-cli 2.1.7 → 2.1.8-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/CHANGELOG.md +6 -0
  2. package/dist/next/parse/wrapContent.js +16 -2
  3. package/dist/react/jsx/utils/constants.d.ts +3 -0
  4. package/dist/react/jsx/utils/constants.js +6 -2
  5. package/dist/react/jsx/utils/parseStringFunction.js +40 -22
  6. package/dist/react/jsx/utils/validateStringFunction.js +3 -2
  7. package/dist/react/parse/createInlineUpdates.js +7 -3
  8. package/package.json +1 -1
package/CHANGELOG.md CHANGED
@@ -1,5 +1,11 @@
1
1
  # gtx-cli
2
2
 
3
+ ## 2.1.8
4
+
5
+ ### Patch Changes
6
+
7
+ - [#594](https://github.com/generaltranslation/gt/pull/594) [`3fa9c41`](https://github.com/generaltranslation/gt/commit/3fa9c41e2e37933b04e6c3d6c0f94271a07d0ff6) Thanks [@brian-lou](https://github.com/brian-lou)! - Fix <GTProvider> wizard scan behavior
8
+
3
9
  ## 2.1.7
4
10
 
5
11
  ### Patch Changes
package/dist/next/parse/wrapContent.js CHANGED
@@ -61,8 +61,22 @@ export async function wrapContentNext(options, pkg, errors, warnings) {
61
61
  if (pkg === 'gt-next' &&
62
62
  options.addGTProvider &&
63
63
  isHtmlElement(path.node.openingElement)) {
64
- // Find the body element in the HTML children
65
- const bodyElement = path.node.children.find((child) => t.isJSXElement(child) && isBodyElement(child.openingElement));
64
+ // Find the body element recursively in the HTML tree
65
+ const findBodyElement = (children) => {
66
+ for (const child of children) {
67
+ if (t.isJSXElement(child) &&
68
+ isBodyElement(child.openingElement)) {
69
+ return child;
70
+ }
71
+ if (t.isJSXElement(child)) {
72
+ const bodyInChild = findBodyElement(child.children);
73
+ if (bodyInChild)
74
+ return bodyInChild;
75
+ }
76
+ }
77
+ return null;
78
+ };
79
+ const bodyElement = findBodyElement(path.node.children);
66
80
  if (!bodyElement) {
67
81
  warnings.push(`File ${file} has a <html> tag without a <body> tag. Skipping GTProvider insertion.`);
68
82
  return;
package/dist/react/jsx/utils/constants.d.ts CHANGED
@@ -1,3 +1,6 @@
1
+ export declare const MSG_TRANSLATION_HOOK = "msg";
2
+ export declare const INLINE_TRANSLATION_HOOK = "useGT";
3
+ export declare const INLINE_TRANSLATION_HOOK_ASYNC = "getGT";
1
4
  export declare const GT_TRANSLATION_FUNCS: string[];
2
5
  export declare const VARIABLE_COMPONENTS: string[];
3
6
  export declare const GT_ATTRIBUTES_WITH_SUGAR: string[];
package/dist/react/jsx/utils/constants.js CHANGED
@@ -1,7 +1,11 @@
1
+ export const MSG_TRANSLATION_HOOK = 'msg';
2
+ export const INLINE_TRANSLATION_HOOK = 'useGT';
3
+ export const INLINE_TRANSLATION_HOOK_ASYNC = 'getGT';
1
4
  // GT translation functions
2
5
  export const GT_TRANSLATION_FUNCS = [
3
- 'useGT',
4
- 'getGT',
6
+ INLINE_TRANSLATION_HOOK,
7
+ INLINE_TRANSLATION_HOOK_ASYNC,
8
+ MSG_TRANSLATION_HOOK,
5
9
  'T',
6
10
  'Var',
7
11
  'DateTime',
package/dist/react/jsx/utils/parseStringFunction.js CHANGED
@@ -1,6 +1,6 @@
1
1
  import * as t from '@babel/types';
2
2
  import { isStaticExpression } from '../evaluateJsx.js';
3
- import { GT_ATTRIBUTES_WITH_SUGAR, mapAttributeName } from './constants.js';
3
+ import { GT_ATTRIBUTES_WITH_SUGAR, MSG_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, } from './constants.js';
4
4
  import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, } from '../../../console/index.js';
5
5
  import generateModule from '@babel/generator';
6
6
  import traverseModule from '@babel/traverse';
@@ -22,7 +22,7 @@ import resolve from 'resolve';
22
22
  * - Metadata extraction from options object
23
23
  * - Error reporting for non-static expressions and template literals with expressions
24
24
  */
25
- function processTranslationCall(tPath, updates, errors, file) {
25
+ function processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData) {
26
26
  if (tPath.parent.type === 'CallExpression' &&
27
27
  tPath.parent.arguments.length > 0) {
28
28
  const arg = tPath.parent.arguments[0];
@@ -43,7 +43,7 @@ function processTranslationCall(tPath, updates, errors, file) {
43
43
  if (!result.isStatic) {
44
44
  errors.push(warnNonStaticExpressionSync(file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
45
45
  }
46
- if (result.isStatic && result.value) {
46
+ if (result.isStatic && result.value && !ignoreAdditionalData) {
47
47
  // Map $id and $context to id and context
48
48
  metadata[mapAttributeName(attribute)] = result.value;
49
49
  }
@@ -145,11 +145,11 @@ function resolveVariableAliases(scope, variableName, visited = new Set()) {
145
145
  * This covers both direct translation calls (t('hello')) and prop drilling
146
146
  * where the translation callback is passed to other functions (getData(t)).
147
147
  */
148
- function handleFunctionCall(tPath, updates, errors, file, importMap) {
148
+ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData) {
149
149
  if (tPath.parent.type === 'CallExpression' &&
150
150
  tPath.parent.callee === tPath.node) {
151
151
  // Direct translation call: t('hello')
152
- processTranslationCall(tPath, updates, errors, file);
152
+ processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData);
153
153
  }
154
154
  else if (tPath.parent.type === 'CallExpression' &&
155
155
  t.isExpression(tPath.node) &&
@@ -161,7 +161,7 @@ function handleFunctionCall(tPath, updates, errors, file, importMap) {
161
161
  const calleeBinding = tPath.scope.getBinding(callee.name);
162
162
  if (calleeBinding && calleeBinding.path.isFunction()) {
163
163
  const functionPath = calleeBinding.path;
164
- processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file);
164
+ processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file, ignoreAdditionalData);
165
165
  }
166
166
  // Handle arrow functions assigned to variables: const getData = (t) => {...}
167
167
  else if (calleeBinding &&
@@ -170,14 +170,14 @@ function handleFunctionCall(tPath, updates, errors, file, importMap) {
170
170
  (t.isArrowFunctionExpression(calleeBinding.path.node.init) ||
171
171
  t.isFunctionExpression(calleeBinding.path.node.init))) {
172
172
  const initPath = calleeBinding.path.get('init');
173
- processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file);
173
+ processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file, ignoreAdditionalData);
174
174
  }
175
175
  // If not found locally, check if it's an imported function
176
176
  else if (importMap.has(callee.name)) {
177
177
  const importPath = importMap.get(callee.name);
178
178
  const resolvedPath = resolveImportPath(file, importPath);
179
179
  if (resolvedPath) {
180
- findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors);
180
+ findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, ignoreAdditionalData);
181
181
  }
182
182
  }
183
183
  }
@@ -188,12 +188,12 @@ function handleFunctionCall(tPath, updates, errors, file, importMap) {
188
188
  * Validates the function has enough parameters and traces how the translation callback
189
189
  * is used within that function's body.
190
190
  */
191
- function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath) {
191
+ function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath, ignoreAdditionalData) {
192
192
  if (functionNode.params.length > argIndex) {
193
193
  const param = functionNode.params[argIndex];
194
194
  const paramName = extractParameterName(param);
195
195
  if (paramName) {
196
- findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath);
196
+ findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath, ignoreAdditionalData);
197
197
  }
198
198
  }
199
199
  }
@@ -205,7 +205,7 @@ function processFunctionIfMatches(_functionName, argIndex, functionNode, functio
205
205
  * Example: In function getInfo(t) { return t('hello'); }, this finds the t('hello') call.
206
206
  * Example: In function getData(t) { return getFooter(t); }, this finds and traces into getFooter.
207
207
  */
208
- function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file) {
208
+ function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file, ignoreAdditionalData) {
209
209
  // Look for the function body and find all usages of the parameter
210
210
  if (functionPath.isFunction()) {
211
211
  const functionScope = functionPath.scope;
@@ -220,7 +220,7 @@ function findFunctionParameterUsage(functionPath, parameterName, updates, errors
220
220
  const binding = functionScope.bindings[name];
221
221
  if (binding) {
222
222
  binding.referencePaths.forEach((refPath) => {
223
- handleFunctionCall(refPath, updates, errors, file, importMap);
223
+ handleFunctionCall(refPath, updates, errors, file, importMap, ignoreAdditionalData);
224
224
  });
225
225
  }
226
226
  });
@@ -299,7 +299,7 @@ function resolveImportPath(currentFile, importPath) {
299
299
  * - export function getInfo(t) { ... }
300
300
  * - const getInfo = (t) => { ... }
301
301
  */
302
- function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
302
+ function findFunctionInFile(filePath, functionName, argIndex, updates, errors, ignoreAdditionalData) {
303
303
  try {
304
304
  const code = fs.readFileSync(filePath, 'utf8');
305
305
  const ast = parse(code, {
@@ -310,7 +310,7 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
310
310
  // Handle function declarations: function getInfo(t) { ... }
311
311
  FunctionDeclaration(path) {
312
312
  if (path.node.id?.name === functionName) {
313
- processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath);
313
+ processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath, ignoreAdditionalData);
314
314
  }
315
315
  },
316
316
  // Handle variable declarations: const getInfo = (t) => { ... }
@@ -321,7 +321,7 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
321
321
  (t.isArrowFunctionExpression(path.node.init) ||
322
322
  t.isFunctionExpression(path.node.init))) {
323
323
  const initPath = path.get('init');
324
- processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath);
324
+ processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath, ignoreAdditionalData);
325
325
  }
326
326
  },
327
327
  });
@@ -348,21 +348,33 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
348
348
  const importMap = buildImportMap(path.scope.getProgramParent().path);
349
349
  const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
350
350
  for (const refPath of referencePaths) {
351
- // Find call expressions of useGT() / await getGT()
351
+ // Handle msg() calls directly without variable assignment
352
+ if (originalName === MSG_TRANSLATION_HOOK) {
353
+ const ignoreAdditionalData = true;
354
+ // Check if this is a direct call to msg('string')
355
+ if (refPath.parent.type === 'CallExpression' &&
356
+ refPath.parent.callee === refPath.node) {
357
+ processTranslationCall(refPath, updates, errors, file, ignoreAdditionalData);
358
+ }
359
+ continue;
360
+ }
361
+ // Handle useGT() and getGT() calls that need variable assignment
352
362
  const callExpr = refPath.findParent((p) => p.isCallExpression());
353
363
  if (callExpr) {
354
364
  // Get the parent, handling both await and non-await cases
355
365
  const parentPath = callExpr.parentPath;
356
366
  const parentFunction = refPath.getFunctionParent();
357
367
  const asyncScope = parentFunction?.node.async;
358
- if (asyncScope && originalName === 'useGT') {
368
+ if (asyncScope && originalName === INLINE_TRANSLATION_HOOK) {
359
369
  errors.push(warnAsyncUseGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
360
370
  return;
361
371
  }
362
- else if (!asyncScope && originalName === 'getGT') {
372
+ else if (!asyncScope &&
373
+ originalName === INLINE_TRANSLATION_HOOK_ASYNC) {
363
374
  errors.push(warnSyncGetGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
364
375
  return;
365
376
  }
377
+ const ignoreAdditionalData = false;
366
378
  const effectiveParent = parentPath?.node.type === 'AwaitExpression'
367
379
  ? parentPath.parentPath
368
380
  : parentPath;
@@ -372,10 +384,16 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
372
384
  const tFuncName = effectiveParent.node.id.name;
373
385
  // Get the scope from the variable declaration
374
386
  const variableScope = effectiveParent.scope;
375
- const tReferencePaths = variableScope.bindings[tFuncName]?.referencePaths || [];
376
- for (const tPath of tReferencePaths) {
377
- handleFunctionCall(tPath, updates, errors, file, importMap);
378
- }
387
+ // Resolve all aliases of the translation function
388
+ // Example: translate -> [translate, t, a, b] for const t = translate; const a = t; const b = a;
389
+ const allTranslationNames = resolveVariableAliases(variableScope, tFuncName);
390
+ // Process references for all translation function names and their aliases
391
+ allTranslationNames.forEach((name) => {
392
+ const tReferencePaths = variableScope.bindings[name]?.referencePaths || [];
393
+ for (const tPath of tReferencePaths) {
394
+ handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData);
395
+ }
396
+ });
379
397
  }
380
398
  }
381
399
  }
package/dist/react/jsx/utils/validateStringFunction.js CHANGED
@@ -1,4 +1,5 @@
1
1
  import { warnAsyncUseGT, warnSyncGetGT } from '../../../console/index.js';
2
+ import { INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, } from './constants.js';
2
3
  /**
3
4
  * Validate useGT() / await getGT() calls
4
5
  * 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
12
13
  callPath.node.callee.name === localImportName) {
13
14
  // Check the function scope
14
15
  const functionScope = callPath.getFunctionParent();
15
- if (originalImportName === 'useGT') {
16
+ if (originalImportName === INLINE_TRANSLATION_HOOK) {
16
17
  // useGT should NOT be in an async function
17
18
  if (functionScope && functionScope.node.async) {
18
19
  errors.push(warnAsyncUseGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));
19
20
  }
20
21
  }
21
- else if (originalImportName === 'getGT') {
22
+ else if (originalImportName === INLINE_TRANSLATION_HOOK_ASYNC) {
22
23
  // getGT should be in an async function
23
24
  if (!functionScope || !functionScope.node.async) {
24
25
  errors.push(warnSyncGetGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));
package/dist/react/parse/createInlineUpdates.js CHANGED
@@ -8,7 +8,7 @@ import { parseJSXElement } from '../jsx/utils/parseJsx.js';
8
8
  import { parseStrings } from '../jsx/utils/parseStringFunction.js';
9
9
  import { extractImportName } from '../jsx/utils/parseAst.js';
10
10
  import { logError } from '../../console/logging.js';
11
- import { GT_TRANSLATION_FUNCS } from '../jsx/utils/constants.js';
11
+ import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, MSG_TRANSLATION_HOOK, } from '../jsx/utils/constants.js';
12
12
  import { matchFiles } from '../../fs/matchFiles.js';
13
13
  import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
14
14
  export async function createInlineUpdates(pkg, validate, filePatterns) {
@@ -38,7 +38,9 @@ export async function createInlineUpdates(pkg, validate, filePatterns) {
38
38
  if (path.node.source.value.startsWith(pkg)) {
39
39
  const importName = extractImportName(path.node, pkg, GT_TRANSLATION_FUNCS);
40
40
  for (const name of importName) {
41
- if (name.original === 'useGT' || name.original === 'getGT') {
41
+ if (name.original === INLINE_TRANSLATION_HOOK ||
42
+ name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
43
+ name.original === MSG_TRANSLATION_HOOK) {
42
44
  translationPaths.push({
43
45
  localName: name.local,
44
46
  path,
@@ -65,7 +67,9 @@ export async function createInlineUpdates(pkg, validate, filePatterns) {
65
67
  if (parentPath.isVariableDeclaration()) {
66
68
  const importName = extractImportName(parentPath.node, pkg, GT_TRANSLATION_FUNCS);
67
69
  for (const name of importName) {
68
- if (name.original === 'useGT' || name.original === 'getGT') {
70
+ if (name.original === INLINE_TRANSLATION_HOOK ||
71
+ name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
72
+ name.original === MSG_TRANSLATION_HOOK) {
69
73
  translationPaths.push({
70
74
  localName: name.local,
71
75
  path: parentPath,
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "gtx-cli",
3
- "version": "2.1.7",
3
+ "version": "2.1.8-alpha.1",
4
4
  "main": "dist/index.js",
5
5
  "bin": "dist/main.js",
6
6
  "files": [