gtx-cli 2.5.0-alpha.0 → 2.5.0-alpha.1

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

@@ -8,9 +8,12 @@ import traverseModule from '@babel/traverse';
 const generate = generateModule.default || generateModule;
 const traverse = traverseModule.default || traverseModule;
 import fs from 'node:fs';
+import path from 'node:path';
 import { parse } from '@babel/parser';
-import { resolveImportPath } from './resolveImportPath.js';
-import { buildImportMap } from './buildImportMap.js';
+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}`
@@ -109,6 +112,35 @@ function extractParameterName(param) {
     }
     return null;
 }
+/**
+ * Builds a map of imported function names to their import paths from a given program path.
+ * Handles both named imports and default imports.
+ *
+ * Example: import { getInfo } from './constants' -> Map { 'getInfo' => './constants' }
+ * Example: import utils from './utils' -> Map { 'utils' => './utils' }
+ */
+function buildImportMap(programPath) {
+    const importMap = new Map();
+    programPath.traverse({
+        ImportDeclaration(importPath) {
+            if (t.isStringLiteral(importPath.node.source)) {
+                const importSource = importPath.node.source.value;
+                importPath.node.specifiers.forEach((spec) => {
+                    if (t.isImportSpecifier(spec) &&
+                        t.isIdentifier(spec.imported) &&
+                        t.isIdentifier(spec.local)) {
+                        importMap.set(spec.local.name, importSource);
+                    }
+                    else if (t.isImportDefaultSpecifier(spec) &&
+                        t.isIdentifier(spec.local)) {
+                        importMap.set(spec.local.name, importSource);
+                    }
+                });
+            }
+        },
+    });
+    return importMap;
+}
 /**
  * Recursively resolves variable assignments to find all aliases of a translation callback parameter.
  * Handles cases like: const t = translate; const a = translate; const b = a; const c = b;
@@ -180,7 +212,7 @@ function handleFunctionCall(tPath, updates, errors, warnings, file, importMap, i
             // 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, parsingOptions, resolveImportPathCache);
+                const resolvedPath = resolveImportPath(file, importPath, parsingOptions);
                 if (resolvedPath) {
                     processFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, warnings, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
                 }
@@ -231,6 +263,111 @@ function findFunctionParameterUsage(functionPath, parameterName, updates, errors
         });
     }
 }
+/**
+ * Resolves import paths to absolute file paths using battle-tested libraries.
+ * Handles relative paths, TypeScript paths, and node module resolution.
+ *
+ * Examples:
+ * - './constants' -> '/full/path/to/constants.ts'
+ * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
+ * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
+ */
+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, mainFields);
+        // First try without any extension
+        let tsResolved = matchPath(importPath);
+        if (tsResolved && fs.existsSync(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)) {
+                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)) {
+                    result = resolvedWithExt;
+                    resolveImportPathCache.set(cacheKey, result);
+                    return result;
+                }
+            }
+        }
+    }
+    // 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 {
+        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 {
+                result = resolve.sync(tsPath, { basedir, extensions });
+                resolveImportPathCache.set(cacheKey, result);
+                return result;
+            }
+            catch {
+                // Continue to return null
+            }
+        }
+        else if (importPath.endsWith('.jsx')) {
+            const tsxPath = importPath.replace(/\.jsx$/, '.tsx');
+            try {
+                result = resolve.sync(tsxPath, { basedir, extensions });
+                resolveImportPathCache.set(cacheKey, result);
+                return result;
+            }
+            catch {
+                // Continue to return null
+            }
+        }
+        resolveImportPathCache.set(cacheKey, null);
+        return null;
+    }
+}
 /**
  * Searches for a specific user-defined function in a file and analyzes how a translation callback
  * parameter (at argIndex position) is used within that function.
@@ -309,7 +446,7 @@ function processFunctionInFile(filePath, functionName, argIndex, updates, errors
         // If function not found, follow re-exports
         if (!found && reExports.length > 0) {
             for (const reExportPath of reExports) {
-                const resolvedPath = resolveImportPath(filePath, reExportPath, parsingOptions, resolveImportPathCache);
+                const resolvedPath = resolveImportPath(filePath, reExportPath, parsingOptions);
                 if (resolvedPath) {
                     processFunctionInFile(resolvedPath, functionName, argIndex, updates, errors, warnings, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions, visited);
                 }

package/dist/react/parse/createInlineUpdates.js

@@ -1,12 +1,16 @@
 import fs from 'node:fs';
 import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
 import { hashSource } from 'generaltranslation/id';
-import { parseTranslationComponent } from '../jsx/utils/jsxParsing/parseJsx.js';
+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, 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';
-import { getPathsAndAliases } from '../jsx/utils/getPathsAndAliases.js';
 export async function createInlineUpdates(pkg, validate, filePatterns, parsingOptions) {
     const updates = [];
     const errors = [];
@@ -26,28 +30,75 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
             logError(`Error parsing file ${file}: ${error}`);
             continue;
         }
+        const importAliases = {};
         // First pass: collect imports and process translation functions
-        const { importAliases, inlineTranslationPaths, translationComponentPaths } = getPathsAndAliases(ast, pkg);
+        const translationPaths = [];
+        traverse(ast, {
+            ImportDeclaration(path) {
+                if (path.node.source.value.startsWith(pkg)) {
+                    const importName = extractImportName(path.node, pkg, GT_TRANSLATION_FUNCS);
+                    for (const name of importName) {
+                        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,
+                                originalName: name.original,
+                            });
+                        }
+                        else {
+                            importAliases[name.local] = name.original;
+                        }
+                    }
+                }
+            },
+            VariableDeclarator(path) {
+                // Check if the init is a require call
+                if (path.node.init?.type === 'CallExpression' &&
+                    path.node.init.callee.type === 'Identifier' &&
+                    path.node.init.callee.name === 'require') {
+                    // Check if it's requiring our package
+                    const args = path.node.init.arguments;
+                    if (args.length === 1 &&
+                        args[0].type === 'StringLiteral' &&
+                        args[0].value.startsWith(pkg)) {
+                        const parentPath = path.parentPath;
+                        if (parentPath.isVariableDeclaration()) {
+                            const importName = extractImportName(parentPath.node, pkg, GT_TRANSLATION_FUNCS);
+                            for (const name of importName) {
+                                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,
+                                        originalName: name.original,
+                                    });
+                                }
+                                else {
+                                    importAliases[name.local] = name.original;
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        });
         // Process translation functions asynchronously
-        for (const { localName: name, originalName, path, } of inlineTranslationPaths) {
+        for (const { localName: name, originalName, path } of translationPaths) {
             parseStrings(name, originalName, path, updates, errors, warnings, file, parsingOptions);
         }
         // Parse <T> components
-        for (const { localName, path } of translationComponentPaths) {
-            parseTranslationComponent({
-                importAliases: importAliases,
-                originalName: localName,
-                localName,
-                ast,
-                pkg,
-                path,
-                updates,
-                errors,
-                warnings,
-                file,
-                parsingOptions,
-            });
-        }
+        traverse(ast, {
+            JSXElement(path) {
+                parseJSXElement(importAliases, path.node, updates, errors, warnings, file);
+            },
+        });
         // Extra validation (for Locadex)
         // Done in parseStrings() atm
         // if (validate) {

package/dist/types/branch.d.ts

@@ -0,0 +1,14 @@
+export type BranchData = {
+    currentBranch: {
+        id: string;
+        name: string;
+    };
+    incomingBranch: {
+        id: string;
+        name: string;
+    } | null;
+    checkedOutBranch: {
+        id: string;
+        name: string;
+    } | null;
+};

package/dist/types/branch.js

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

package/dist/types/data.d.ts

@@ -17,7 +17,7 @@ export type JSONDictionary = {
 export type FlattenedJSONDictionary = {
     [key: string]: string;
 };
-export type { FileFormat, DataFormat, FileToTranslate, } from 'generaltranslation/types';
+export type { FileFormat, DataFormat, FileToUpload, } from 'generaltranslation/types';
 export type JsxChildren = string | string[] | any;
 export type Translations = {
     [key: string]: JsxChildren;

package/dist/types/files.d.ts

@@ -1 +1,8 @@
 export type FileMapping = Record<string, Record<string, string>>;
+export type FileProperties = {
+    versionId: string;
+    fileName: string;
+    fileId: string;
+    locale: string;
+    branchId: string;
+};

package/dist/types/index.d.ts

@@ -133,6 +133,13 @@ export type Settings = {
     options?: AdditionalOptions;
     modelProvider?: string;
     parsingOptions: ParsingConfigOptions;
+    branchOptions: BranchOptions;
+};
+export type BranchOptions = {
+    currentBranch?: string;
+    autoDetectBranches?: boolean;
+    remoteName: string;
+    enabled: boolean;
 };
 export type AdditionalOptions = {
     jsonSchema?: {

package/dist/utils/SpinnerManager.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Centralized spinner management for tracking multiple async operations
+ */
+export declare class SpinnerManager {
+    private spinners;
+    /**
+     * Run an async operation with a spinner
+     */
+    run<T>(id: string, message: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Mark a spinner as successful
+     */
+    succeed(id: string, message: string): void;
+    /**
+     * Mark a spinner as warning
+     */
+    warn(id: string, message: string): void;
+    /**
+     * Start a new spinner
+     */
+    start(id: string, message: string): void;
+    /**
+     * Stop a specific spinner
+     */
+    stop(id: string, message?: string): void;
+    /**
+     * Stop all running spinners
+     */
+    stopAll(): void;
+}

package/dist/utils/SpinnerManager.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import { createSpinner } from '../console/logging.js';
+/**
+ * Centralized spinner management for tracking multiple async operations
+ */
+export class SpinnerManager {
+    spinners = new Map();
+    /**
+     * Run an async operation with a spinner
+     */
+    async run(id, message, fn) {
+        const spinner = createSpinner('dots');
+        this.spinners.set(id, spinner);
+        spinner.start(message);
+        try {
+            const result = await fn();
+            spinner.stop(chalk.green('✓'));
+            return result;
+        }
+        catch (error) {
+            spinner.stop(chalk.red('✗'));
+            throw error;
+        }
+        finally {
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Mark a spinner as successful
+     */
+    succeed(id, message) {
+        const spinner = this.spinners.get(id);
+        if (spinner) {
+            spinner.stop(chalk.green(message));
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Mark a spinner as warning
+     */
+    warn(id, message) {
+        const spinner = this.spinners.get(id);
+        if (spinner) {
+            spinner.stop(chalk.yellow(message));
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Start a new spinner
+     */
+    start(id, message) {
+        const spinner = createSpinner('dots');
+        this.spinners.set(id, spinner);
+        spinner.start(message);
+    }
+    /**
+     * Stop a specific spinner
+     */
+    stop(id, message) {
+        const spinner = this.spinners.get(id);
+        if (spinner) {
+            spinner.stop(message);
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Stop all running spinners
+     */
+    stopAll() {
+        this.spinners.forEach((s) => s.stop());
+        this.spinners.clear();
+    }
+}

package/dist/utils/gitDiff.js

@@ -9,24 +9,26 @@ const execFileAsync = promisify(execFile);
  * Throws if git is unavailable or another error occurs.
  */
 export async function getGitUnifiedDiff(oldPath, newPath) {
-    const res = await execFileAsync('git', [
-        'diff',
-        '--no-index',
-        '--text',
-        '--unified=3',
-        '--no-color',
-        '--',
-        oldPath,
-        newPath,
-    ], {
-        windowsHide: true,
-    }).catch((error) => {
+    try {
+        const res = await execFileAsync('git', [
+            'diff',
+            '--no-index',
+            '--text',
+            '--unified=3',
+            '--no-color',
+            '--',
+            oldPath,
+            newPath,
+        ], {
+            windowsHide: true,
+        });
+        return res.stdout || '';
+    }
+    catch (error) {
         // Exit code 1 means differences found; stdout contains the diff
         if (error && error.code === 1 && typeof error.stdout === 'string') {
-            return { stdout: error.stdout };
+            return error.stdout;
         }
         throw error;
-    });
-    // When there are no changes, stdout is empty string and exit code 0
-    return res.stdout || '';
+    }
 }

package/dist/workflow/BranchStep.d.ts

@@ -0,0 +1,13 @@
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+import { BranchData } from '../types/branch.js';
+export declare class BranchStep extends WorkflowStep<null, BranchData | null> {
+    private spinner;
+    private branchData;
+    private settings;
+    private gt;
+    constructor(gt: GT, settings: Settings);
+    run(): Promise<BranchData | null>;
+    wait(): Promise<void>;
+}

package/dist/workflow/BranchStep.js

@@ -0,0 +1,131 @@
+import { WorkflowStep } from './Workflow.js';
+import { createSpinner, logError, logErrorAndExit, } from '../console/logging.js';
+import chalk from 'chalk';
+import { getCurrentBranch, getIncomingBranches, getCheckedOutBranches, } from '../git/branches.js';
+import { ApiError } from 'generaltranslation/errors';
+// Step 1: Resolve the current branch id & update API with branch information
+export class BranchStep extends WorkflowStep {
+    spinner = createSpinner('dots');
+    branchData;
+    settings;
+    gt;
+    constructor(gt, settings) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+        this.branchData = {
+            currentBranch: {
+                id: '',
+                name: '',
+            },
+            incomingBranch: null,
+            checkedOutBranch: null,
+        };
+    }
+    async run() {
+        this.spinner.start(`Resolving branch information...`);
+        // First get some info about the branches we're working with
+        let current = null;
+        let incoming = [];
+        let checkedOut = [];
+        let useDefaultBranch = true;
+        if (this.settings.branchOptions.enabled &&
+            this.settings.branchOptions.autoDetectBranches) {
+            const [currentResult, incomingResult, checkedOutResult] = await Promise.all([
+                getCurrentBranch(this.settings.branchOptions.remoteName),
+                getIncomingBranches(this.settings.branchOptions.remoteName),
+                getCheckedOutBranches(this.settings.branchOptions.remoteName),
+            ]);
+            current = currentResult;
+            incoming = incomingResult;
+            checkedOut = checkedOutResult;
+            useDefaultBranch = false;
+        }
+        if (this.settings.branchOptions.enabled &&
+            this.settings.branchOptions.currentBranch) {
+            current = {
+                currentBranchName: this.settings.branchOptions.currentBranch,
+                defaultBranch: current?.defaultBranch ?? false, // we have no way of knowing if this is the default branch without using the auto-detection logic
+            };
+            useDefaultBranch = false;
+        }
+        const branchData = await this.gt.queryBranchData({
+            branchNames: [
+                ...(current ? [current.currentBranchName] : []),
+                ...incoming,
+                ...checkedOut,
+            ],
+        });
+        if (useDefaultBranch) {
+            if (!branchData.defaultBranch) {
+                const createBranchResult = await this.gt.createBranch({
+                    branchName: 'main', // name doesn't matter for default branch
+                    defaultBranch: true,
+                });
+                this.branchData.currentBranch = createBranchResult.branch;
+            }
+            else {
+                this.branchData.currentBranch = branchData.defaultBranch;
+            }
+        }
+        else {
+            if (!current) {
+                logErrorAndExit('Failed to determine the current branch. Please specify a custom branch or enable automatic branch detection.');
+            }
+            const currentBranch = branchData.branches.find((b) => b.name === current.currentBranchName);
+            if (!currentBranch) {
+                try {
+                    const createBranchResult = await this.gt.createBranch({
+                        branchName: current.currentBranchName,
+                        defaultBranch: current.defaultBranch,
+                    });
+                    this.branchData.currentBranch = createBranchResult.branch;
+                }
+                catch (error) {
+                    if (error instanceof ApiError && error.code === 403) {
+                        logError('Failed to create branch. To enable branching, please upgrade your plan.');
+                        // retry with default branch
+                        const createBranchResult = await this.gt.createBranch({
+                            branchName: 'main', // name doesn't matter for default branch
+                            defaultBranch: true,
+                        });
+                        this.branchData.currentBranch = createBranchResult.branch;
+                    }
+                }
+            }
+            else {
+                this.branchData.currentBranch = currentBranch;
+            }
+        }
+        // Now set the incoming and checked out branches (first one that exists)
+        this.branchData.incomingBranch =
+            incoming
+                .map((b) => {
+                const branch = branchData.branches.find((bb) => bb.name === b);
+                if (branch) {
+                    return branch;
+                }
+                else {
+                    return null;
+                }
+            })
+                .filter((b) => b !== null)[0] ?? null;
+        this.branchData.checkedOutBranch =
+            checkedOut
+                .map((b) => {
+                const branch = branchData.branches.find((bb) => bb.name === b);
+                if (branch) {
+                    return branch;
+                }
+                else {
+                    return null;
+                }
+            })
+                .filter((b) => b !== null)[0] ?? null;
+        this.spinner.stop(chalk.green('Branch information resolved successfully'));
+        return this.branchData;
+    }
+    async wait() {
+        return;
+    }
+}

package/dist/workflow/DownloadStep.d.ts

@@ -0,0 +1,19 @@
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+import { FileStatusTracker } from './PollJobsStep.js';
+export type DownloadTranslationsInput = {
+    fileTracker: FileStatusTracker;
+    resolveOutputPath: (sourcePath: string, locale: string) => string | null;
+    forceDownload?: boolean;
+};
+export declare class DownloadTranslationsStep extends WorkflowStep<DownloadTranslationsInput, boolean> {
+    private gt;
+    private settings;
+    private spinner;
+    constructor(gt: GT, settings: Settings);
+    run({ fileTracker, resolveOutputPath, forceDownload, }: DownloadTranslationsInput): Promise<boolean>;
+    private downloadFiles;
+    private downloadFilesWithRetry;
+    wait(): Promise<void>;
+}