gtx-cli 2.4.5 → 2.4.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.4.7
+
+### Patch Changes
+
+- [#767](https://github.com/generaltranslation/gt/pull/767) [`b27a947`](https://github.com/generaltranslation/gt/commit/b27a947a46d2ad802278d79d45d25cdccd7193d5) Thanks [@brian-lou](https://github.com/brian-lou)! - Fix monorepo in-line string resolution
+
+## 2.4.6
+
+### Patch Changes
+
+- [#763](https://github.com/generaltranslation/gt/pull/763) [`b6a79a8`](https://github.com/generaltranslation/gt/commit/b6a79a868630725eb1106faaa2c385c305891e9c) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Allow lists for overrides in gt.config.json
+
 ## 2.4.5
 
 ### Patch Changes

package/dist/config/generateSettings.js

@@ -155,6 +155,10 @@ export async function generateSettings(flags, cwd = process.cwd()) {
             }
         }
     }
+    // Add parsing options if not provided
+    mergedOptions.parsingOptions = mergedOptions.parsingOptions || {};
+    mergedOptions.parsingOptions.conditionNames = mergedOptions.parsingOptions
+        .conditionNames || ['browser', 'module', 'import', 'require', 'default'];
     // if there's no existing config file, creates one
     // does not include the API key to avoid exposing it
     if (!fs.existsSync(mergedOptions.config)) {

package/dist/formats/files/fileMapping.js

@@ -44,6 +44,39 @@ export function createFileMapping(filePaths, placeholderPaths, transformPaths, t
                         return path.join(directory, transformedFileName);
                     });
                 }
+                else if (Array.isArray(transformPath)) {
+                    // transformPath is an array of TransformOption objects
+                    const targetLocaleProperties = getLocaleProperties(locale);
+                    const defaultLocaleProperties = getLocaleProperties(defaultLocale);
+                    translatedFiles = translatedFiles.map((filePath) => {
+                        const relativePath = getRelative(filePath);
+                        // Try each transform in order until one matches
+                        for (const transform of transformPath) {
+                            if (!transform.replace || typeof transform.replace !== 'string') {
+                                continue;
+                            }
+                            // Replace all locale property placeholders in the replace string
+                            const replaceString = replaceLocalePlaceholders(transform.replace, targetLocaleProperties);
+                            if (transform.match && typeof transform.match === 'string') {
+                                // Replace locale placeholders in the match string using defaultLocale properties
+                                let matchString = transform.match;
+                                matchString = replaceLocalePlaceholders(matchString, defaultLocaleProperties);
+                                const regex = new RegExp(matchString);
+                                if (regex.test(relativePath)) {
+                                    // This transform matches, apply it and break
+                                    const transformedPath = relativePath.replace(new RegExp(matchString, 'g'), replaceString);
+                                    return path.resolve(transformedPath);
+                                }
+                            }
+                            else {
+                                // No match provided: treat as a direct replacement (override)
+                                return path.resolve(replaceString);
+                            }
+                        }
+                        // If no transforms matched, return the original path
+                        return filePath;
+                    });
+                }
                 else {
                     // transformPath is an object
                     const targetLocaleProperties = getLocaleProperties(locale);

package/dist/fs/config/parseFilesConfig.d.ts

@@ -21,7 +21,7 @@ export declare function resolveFiles(files: FilesOptions, locale: string, locale
     placeholderPaths: ResolvedFiles;
     transformPaths: TransformFiles;
 };
-export declare function expandGlobPatterns(cwd: string, includePatterns: string[], excludePatterns: string[], locale: string, locales: string[], transformPatterns?: TransformOption | string, compositePatterns?: string[]): {
+export declare function expandGlobPatterns(cwd: string, includePatterns: string[], excludePatterns: string[], locale: string, locales: string[], transformPatterns?: TransformOption | string | TransformOption[], compositePatterns?: string[]): {
     resolvedPaths: string[];
     placeholderPaths: string[];
 };

package/dist/fs/config/parseFilesConfig.js

@@ -41,8 +41,9 @@ export function resolveFiles(files, locale, locales, cwd, compositePatterns) {
         // ==== TRANSFORMS ==== //
         const transform = files[fileType]?.transform;
         if (transform &&
-            !Array.isArray(transform) &&
-            (typeof transform === 'string' || typeof transform === 'object')) {
+            (typeof transform === 'string' ||
+                typeof transform === 'object' ||
+                Array.isArray(transform))) {
             transformPaths[fileType] = transform;
         }
         // ==== PLACEHOLDERS ==== //

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

@@ -1,5 +1,10 @@
 import { NodePath } from '@babel/traverse';
 import { Updates } from '../../../types/index.js';
+import type { ParsingConfigOptions } from '../../../types/parsing.js';
+/**
+ * Clears all caches. Useful for testing or when file system changes.
+ */
+export declare function clearParsingCaches(): void;
 /**
  * Main entry point for parsing translation strings from useGT() and getGT() calls.
  *
@@ -13,4 +18,4 @@ import { Updates } from '../../../types/index.js';
  * - const { home } = getInfo(t); // getInfo is imported from './constants'
  * - This will parse constants.ts to find translation calls within getInfo function
  */
-export declare function parseStrings(importName: string, originalName: string, path: NodePath, updates: Updates, errors: string[], file: string): void;
+export declare function parseStrings(importName: string, originalName: string, path: NodePath, updates: Updates, errors: string[], file: string, parsingOptions: ParsingConfigOptions): void;

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

@@ -12,6 +12,27 @@ import path from 'node:path';
 import { parse } from '@babel/parser';
 import { createMatchPath, loadConfig } from 'tsconfig-paths';
 import resolve from 'resolve';
+import enhancedResolve from 'enhanced-resolve';
+const { ResolverFactory } = enhancedResolve;
+/**
+ * Cache for resolved import paths to avoid redundant I/O operations.
+ * Key: `${currentFile}::${importPath}`
+ * Value: resolved absolute path or null
+ */
+const resolveImportPathCache = new Map();
+/**
+ * Cache for processed functions to avoid re-parsing the same files.
+ * Key: `${filePath}::${functionName}::${argIndex}`
+ * Value: boolean indicating whether the function was found and processed
+ */
+const processFunctionCache = new Map();
+/**
+ * Clears all caches. Useful for testing or when file system changes.
+ */
+export function clearParsingCaches() {
+    resolveImportPathCache.clear();
+    processFunctionCache.clear();
+}
 /**
  * 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.
@@ -71,12 +92,16 @@ function processTranslationCall(tPath, updates, errors, file, ignoreAdditionalDa
     }
 }
 /**
- * Extracts the parameter name from a function parameter node, handling TypeScript annotations.
+ * Extracts the parameter name from a function parameter node, handling TypeScript annotations and default values.
  */
 function extractParameterName(param) {
     if (t.isIdentifier(param)) {
         return param.name;
     }
+    // Handle parameters with default values: (gt = () => {})
+    if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
+        return param.left.name;
+    }
     return null;
 }
 /**
@@ -149,7 +174,7 @@ 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, ignoreAdditionalData, ignoreDynamicContent) {
+function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent, parsingOptions) {
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.callee === tPath.node) {
         // Direct translation call: t('hello')
@@ -165,7 +190,7 @@ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAddit
             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, ignoreAdditionalData, ignoreDynamicContent);
+                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
             }
             // Handle arrow functions assigned to variables: const getData = (t) => {...}
             else if (calleeBinding &&
@@ -174,14 +199,14 @@ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAddit
                 (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, ignoreAdditionalData, ignoreDynamicContent);
+                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
             }
             // 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);
+                const resolvedPath = resolveImportPath(file, importPath, parsingOptions);
                 if (resolvedPath) {
-                    findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent);
+                    processFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
                 }
             }
         }
@@ -192,12 +217,12 @@ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAddit
  * 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, ignoreAdditionalData, ignoreDynamicContent) {
+function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent, parsingOptions) {
     if (functionNode.params.length > argIndex) {
         const param = functionNode.params[argIndex];
         const paramName = extractParameterName(param);
         if (paramName) {
-            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent);
+            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
         }
     }
 }
@@ -209,7 +234,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, ignoreAdditionalData, ignoreDynamicContent) {
+function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent, parsingOptions) {
     // Look for the function body and find all usages of the parameter
     if (functionPath.isFunction()) {
         const functionScope = functionPath.scope;
@@ -224,7 +249,7 @@ function findFunctionParameterUsage(functionPath, parameterName, updates, errors
             const binding = functionScope.bindings[name];
             if (binding) {
                 binding.referencePaths.forEach((refPath) => {
-                    handleFunctionCall(refPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent);
+                    handleFunctionCall(refPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
                 });
             }
         });
@@ -239,44 +264,82 @@ function findFunctionParameterUsage(functionPath, parameterName, updates, errors
  * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
  * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
  */
-function resolveImportPath(currentFile, importPath) {
+function resolveImportPath(currentFile, importPath, parsingOptions) {
+    // Check cache first
+    const cacheKey = `${currentFile}::${importPath}`;
+    if (resolveImportPathCache.has(cacheKey)) {
+        return resolveImportPathCache.get(cacheKey);
+    }
     const basedir = path.dirname(currentFile);
     const extensions = ['.tsx', '.ts', '.jsx', '.js'];
+    const mainFields = ['module', 'main'];
+    let result = null;
     // 1. Try tsconfig-paths resolution first (handles TypeScript path mapping)
     const tsConfigResult = loadConfig(basedir);
     if (tsConfigResult.resultType === 'success') {
-        const matchPath = createMatchPath(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, ['main', 'module', 'browser']);
+        const matchPath = createMatchPath(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, mainFields);
         // First try without any extension
         let tsResolved = matchPath(importPath);
         if (tsResolved && fs.existsSync(tsResolved)) {
-            return tsResolved;
+            result = tsResolved;
+            resolveImportPathCache.set(cacheKey, result);
+            return result;
         }
         // Then try with each extension
         for (const ext of extensions) {
             tsResolved = matchPath(importPath + ext);
             if (tsResolved && fs.existsSync(tsResolved)) {
-                return tsResolved;
+                result = tsResolved;
+                resolveImportPathCache.set(cacheKey, result);
+                return result;
             }
             // Also try the resolved path with extension
             tsResolved = matchPath(importPath);
             if (tsResolved) {
                 const resolvedWithExt = tsResolved + ext;
                 if (fs.existsSync(resolvedWithExt)) {
-                    return resolvedWithExt;
+                    result = resolvedWithExt;
+                    resolveImportPathCache.set(cacheKey, result);
+                    return result;
                 }
             }
         }
     }
-    // 2. Fallback to Node.js resolution (handles relative paths and node_modules)
+    // 2. Try enhanced-resolve (handles package.json exports field and modern resolution)
+    try {
+        const resolver = ResolverFactory.createResolver({
+            useSyncFileSystemCalls: true,
+            fileSystem: fs,
+            extensions,
+            // Include 'development' condition to resolve to source files in monorepos
+            conditionNames: parsingOptions.conditionNames, // defaults to ['browser', 'module', 'import', 'require', 'default']. See generateSettings.ts for more details
+            exportsFields: ['exports'],
+            mainFields,
+        });
+        const resolved = resolver.resolveSync({}, basedir, importPath);
+        if (resolved) {
+            result = resolved;
+            resolveImportPathCache.set(cacheKey, result);
+            return result;
+        }
+    }
+    catch {
+        // Fall through to next resolution strategy
+    }
+    // 3. Fallback to Node.js resolution (handles relative paths and node_modules)
     try {
-        return resolve.sync(importPath, { basedir, extensions });
+        result = resolve.sync(importPath, { basedir, extensions });
+        resolveImportPathCache.set(cacheKey, result);
+        return result;
     }
     catch {
         // If resolution fails, try to manually replace .js/.jsx with .ts/.tsx for source files
         if (importPath.endsWith('.js')) {
             const tsPath = importPath.replace(/\.js$/, '.ts');
             try {
-                return resolve.sync(tsPath, { basedir, extensions });
+                result = resolve.sync(tsPath, { basedir, extensions });
+                resolveImportPathCache.set(cacheKey, result);
+                return result;
             }
             catch {
                 // Continue to return null
@@ -285,12 +348,15 @@ function resolveImportPath(currentFile, importPath) {
         else if (importPath.endsWith('.jsx')) {
             const tsxPath = importPath.replace(/\.jsx$/, '.tsx');
             try {
-                return resolve.sync(tsxPath, { basedir, extensions });
+                result = resolve.sync(tsxPath, { basedir, extensions });
+                resolveImportPathCache.set(cacheKey, result);
+                return result;
             }
             catch {
                 // Continue to return null
             }
         }
+        resolveImportPathCache.set(cacheKey, null);
         return null;
     }
 }
@@ -302,19 +368,34 @@ function resolveImportPath(currentFile, importPath) {
  * - function getInfo(t) { ... }
  * - export function getInfo(t) { ... }
  * - const getInfo = (t) => { ... }
+ *
+ * If the function is not found in the file, follows re-exports (export * from './other')
  */
-function findFunctionInFile(filePath, functionName, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent) {
+function processFunctionInFile(filePath, functionName, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent, parsingOptions, visited = new Set()) {
+    // Check cache first to avoid redundant parsing
+    const cacheKey = `${filePath}::${functionName}::${argIndex}`;
+    if (processFunctionCache.has(cacheKey)) {
+        return;
+    }
+    // Prevent infinite loops from circular re-exports
+    if (visited.has(filePath)) {
+        return;
+    }
+    visited.add(filePath);
     try {
         const code = fs.readFileSync(filePath, 'utf8');
         const ast = parse(code, {
             sourceType: 'module',
             plugins: ['jsx', 'typescript'],
         });
+        let found = false;
+        const reExports = [];
         traverse(ast, {
             // Handle function declarations: function getInfo(t) { ... }
             FunctionDeclaration(path) {
                 if (path.node.id?.name === functionName) {
-                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent);
+                    found = true;
+                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
                 }
             },
             // Handle variable declarations: const getInfo = (t) => { ... }
@@ -324,14 +405,52 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors, i
                     path.node.init &&
                     (t.isArrowFunctionExpression(path.node.init) ||
                         t.isFunctionExpression(path.node.init))) {
+                    found = true;
                     const initPath = path.get('init');
-                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent);
+                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
+                }
+            },
+            // Collect re-exports: export * from './other'
+            ExportAllDeclaration(path) {
+                if (t.isStringLiteral(path.node.source)) {
+                    reExports.push(path.node.source.value);
+                }
+            },
+            // Collect named re-exports: export { foo } from './other'
+            ExportNamedDeclaration(path) {
+                if (path.node.source && t.isStringLiteral(path.node.source)) {
+                    // Check if this export includes our function
+                    const exportsFunction = path.node.specifiers.some((spec) => {
+                        if (t.isExportSpecifier(spec)) {
+                            const exportedName = t.isIdentifier(spec.exported)
+                                ? spec.exported.name
+                                : spec.exported.value;
+                            return exportedName === functionName;
+                        }
+                        return false;
+                    });
+                    if (exportsFunction) {
+                        reExports.push(path.node.source.value);
+                    }
                 }
             },
         });
+        // If function not found, follow re-exports
+        if (!found && reExports.length > 0) {
+            for (const reExportPath of reExports) {
+                const resolvedPath = resolveImportPath(filePath, reExportPath, parsingOptions);
+                if (resolvedPath) {
+                    processFunctionInFile(resolvedPath, functionName, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent, parsingOptions, visited);
+                }
+            }
+        }
+        // Mark this function search as processed in the cache
+        processFunctionCache.set(cacheKey, found);
     }
     catch {
         // Silently skip files that can't be parsed or accessed
+        // Still mark as processed to avoid retrying failed parses
+        processFunctionCache.set(cacheKey, false);
     }
 }
 /**
@@ -347,7 +466,7 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors, i
  * - const { home } = getInfo(t); // getInfo is imported from './constants'
  * - This will parse constants.ts to find translation calls within getInfo function
  */
-export function parseStrings(importName, originalName, path, updates, errors, file) {
+export function parseStrings(importName, originalName, path, updates, errors, file, parsingOptions) {
     // First, collect all imports in this file to track cross-file function calls
     const importMap = buildImportMap(path.scope.getProgramParent().path);
     const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
@@ -402,7 +521,7 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
                 allTranslationNames.forEach((name) => {
                     const tReferencePaths = variableScope.bindings[name]?.referencePaths || [];
                     for (const tPath of tReferencePaths) {
-                        handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent);
+                        handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
                     }
                 });
             }

package/dist/react/parse/createInlineUpdates.d.ts

@@ -1,5 +1,6 @@
 import { Updates } from '../../types/index.js';
-export declare function createInlineUpdates(pkg: 'gt-react' | 'gt-next', validate: boolean, filePatterns: string[] | undefined): Promise<{
+import type { ParsingConfigOptions } from '../../types/parsing.js';
+export declare function createInlineUpdates(pkg: 'gt-react' | 'gt-next', validate: boolean, filePatterns: string[] | undefined, parsingOptions: ParsingConfigOptions): Promise<{
     updates: Updates;
     errors: string[];
     warnings: string[];

package/dist/react/parse/createInlineUpdates.js

@@ -11,7 +11,7 @@ import { logError } from '../../console/logging.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) {
+export async function createInlineUpdates(pkg, validate, filePatterns, parsingOptions) {
     const updates = [];
     const errors = [];
     const warnings = new Set();
@@ -91,7 +91,7 @@ export async function createInlineUpdates(pkg, validate, filePatterns) {
         });
         // Process translation functions asynchronously
         for (const { localName: name, originalName, path } of translationPaths) {
-            parseStrings(name, originalName, path, updates, errors, file);
+            parseStrings(name, originalName, path, updates, errors, file, parsingOptions);
         }
         // Parse <T> components
         traverse(ast, {

package/dist/translation/parse.d.ts

@@ -1,4 +1,5 @@
 import { Updates, TranslateFlags } from '../types/index.js';
+import type { ParsingConfigOptions } from '../types/parsing.js';
 /**
  * Searches for gt-react or gt-next dictionary files and creates updates for them,
  * as well as inline updates for <T> tags and useGT()/getGT() calls
@@ -8,7 +9,7 @@ import { Updates, TranslateFlags } from '../types/index.js';
  * @param pkg - The package name
  * @returns An object containing the updates and errors
  */
-export declare function createUpdates(options: TranslateFlags, src: string[] | undefined, sourceDictionary: string | undefined, pkg: 'gt-react' | 'gt-next', validate: boolean): Promise<{
+export declare function createUpdates(options: TranslateFlags, src: string[] | undefined, sourceDictionary: string | undefined, pkg: 'gt-react' | 'gt-next', validate: boolean, parsingOptions: ParsingConfigOptions): Promise<{
     updates: Updates;
     errors: string[];
     warnings: string[];

package/dist/translation/parse.js

@@ -14,7 +14,7 @@ import chalk from 'chalk';
  * @param pkg - The package name
  * @returns An object containing the updates and errors
  */
-export async function createUpdates(options, src, sourceDictionary, pkg, validate) {
+export async function createUpdates(options, src, sourceDictionary, pkg, validate, parsingOptions) {
     let updates = [];
     let errors = [];
     let warnings = [];
@@ -48,7 +48,7 @@ export async function createUpdates(options, src, sourceDictionary, pkg, validat
         }
     }
     // Scan through project for <T> tags
-    const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, src);
+    const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, src, parsingOptions);
     errors = [...errors, ...newErrors];
     warnings = [...warnings, ...newWarnings];
     updates = [...updates, ...newUpdates];

package/dist/translation/stage.js

@@ -15,7 +15,7 @@ export async function aggregateReactTranslations(options, settings, library) {
         ]);
     }
     // ---- CREATING UPDATES ---- //
-    const { updates, errors, warnings } = await createUpdates(options, settings.src, options.dictionary, library, false);
+    const { updates, errors, warnings } = await createUpdates(options, settings.src, options.dictionary, library, false, settings.parsingOptions);
     if (warnings.length > 0) {
         logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content.\n` +
             warnings

package/dist/translation/validate.js

@@ -7,7 +7,7 @@ import { createInlineUpdates } from '../react/parse/createInlineUpdates.js';
 export async function validateProject(settings, pkg, files) {
     if (files && files.length > 0) {
         // Validate specific files using createInlineUpdates
-        const { errors, updates } = await createInlineUpdates(pkg, true, files);
+        const { errors, updates } = await createInlineUpdates(pkg, true, files, settings.parsingOptions);
         if (errors.length > 0) {
             logErrorAndExit(chalk.red(`Error: CLI tool encountered ${errors.length} syntax errors:\n` +
                 errors
@@ -27,7 +27,7 @@ export async function validateProject(settings, pkg, files) {
             './src/dictionary.ts',
         ]);
     }
-    const { updates, errors, warnings } = await createUpdates(settings, settings.src, settings.dictionary, pkg, true);
+    const { updates, errors, warnings } = await createUpdates(settings, settings.src, settings.dictionary, pkg, true, settings.parsingOptions);
     if (warnings.length > 0) {
         logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content.`) +
             '\n' +

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import { CustomMapping } from 'generaltranslation/types';
 import { SUPPORTED_FILE_EXTENSIONS } from '../formats/files/supportedFiles.js';
+import { ParsingConfigOptions } from './parsing.js';
 export type { Updates } from 'generaltranslation/types';
 export type Options = {
     config: string;
@@ -93,13 +94,13 @@ export type TransformOption = {
     replace: string;
 };
 export type TransformFiles = {
-    [K in SupportedFileExtension]?: TransformOption | string;
+    [K in SupportedFileExtension]?: TransformOption | string | TransformOption[];
 };
 export type FilesOptions = {
     [K in SupportedFileExtension]?: {
         include: string[];
         exclude?: string[];
-        transform?: string | TransformOption;
+        transform?: string | TransformOption | TransformOption[];
     };
 } & {
     gt?: {
@@ -130,6 +131,7 @@ export type Settings = {
     framework?: SupportedFrameworks;
     options?: AdditionalOptions;
     modelProvider?: string;
+    parsingOptions: ParsingConfigOptions;
 };
 export type AdditionalOptions = {
     jsonSchema?: {

package/dist/types/parsing.d.ts

@@ -0,0 +1,3 @@
+export type ParsingConfigOptions = {
+    conditionNames: string[];
+};

package/dist/types/parsing.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.4.5",
+  "version": "2.4.7",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -71,6 +71,7 @@
     "chalk": "^5.4.1",
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",
+    "enhanced-resolve": "^5.18.3",
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "fast-json-stable-stringify": "^2.1.0",