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

package/dist/api/sendFiles.js

@@ -1,127 +0,0 @@
-import chalk from 'chalk';
-import { createSpinner, logErrorAndExit, logMessage, logSuccess, } from '../console/logging.js';
-import { gt } from '../utils/gt.js';
-import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
-import { collectAndSendUserEditDiffs } from './collectUserEditDiffs.js';
-/**
- * Sends multiple files for translation to the API
- * @param files - Array of file objects to translate
- * @param options - The options for the API call
- * @returns The translated content or version ID
- */
-export async function sendFiles(files, options, settings) {
-    // Keep track of the most recent spinner so we can stop it on error
-    let currentSpinner = null;
-    logMessage(chalk.cyan('Files to translate:') +
-        '\n' +
-        files
-            .map((file) => {
-            if (file.fileName === TEMPLATE_FILE_NAME) {
-                return `- <React Elements>`;
-            }
-            return `- ${file.fileName}`;
-        })
-            .join('\n'));
-    try {
-        // Step 1: Upload files (get references)
-        const uploadSpinner = createSpinner('dots');
-        currentSpinner = uploadSpinner;
-        uploadSpinner.start(`Uploading ${files.length} file${files.length !== 1 ? 's' : ''} to General Translation API...`);
-        const sourceLocale = settings.defaultLocale;
-        if (!sourceLocale) {
-            uploadSpinner.stop(chalk.red('Missing default source locale'));
-            logErrorAndExit('sendFiles: settings.defaultLocale is required to upload source files');
-        }
-        // Convert FileToTranslate[] -> { source: FileUpload }[]
-        const uploads = files.map(({ content, fileName, fileFormat, dataFormat }) => ({
-            source: {
-                content,
-                fileName,
-                fileFormat,
-                dataFormat,
-                locale: sourceLocale,
-            },
-        }));
-        const upload = await gt.uploadSourceFiles(uploads, {
-            sourceLocale,
-            modelProvider: settings.modelProvider,
-        });
-        uploadSpinner.stop(chalk.green('Files uploaded successfully'));
-        // Calculate timeout once for setup fetching
-        // Accept number or numeric string, default to 600s
-        const timeoutVal = options?.timeout !== undefined ? Number(options.timeout) : 600;
-        const setupTimeoutMs = (Number.isFinite(timeoutVal) ? timeoutVal : 600) * 1000;
-        const setupResult = await gt.setupProject(upload.uploadedFiles, {
-            locales: settings.locales,
-        });
-        if (setupResult?.status === 'queued') {
-            const { setupJobId } = setupResult;
-            const setupSpinner = createSpinner('dots');
-            currentSpinner = setupSpinner;
-            setupSpinner.start('Setting up project...');
-            const start = Date.now();
-            const pollInterval = 2000;
-            let setupCompleted = false;
-            let setupFailedMessage = null;
-            while (true) {
-                const status = await gt.checkSetupStatus(setupJobId);
-                if (status.status === 'completed') {
-                    setupCompleted = true;
-                    break;
-                }
-                if (status.status === 'failed') {
-                    setupFailedMessage = status.error?.message || 'Unknown error';
-                    break;
-                }
-                if (Date.now() - start > setupTimeoutMs) {
-                    setupFailedMessage = 'Timed out while waiting for setup generation';
-                    break;
-                }
-                await new Promise((r) => setTimeout(r, pollInterval));
-            }
-            if (setupCompleted) {
-                setupSpinner.stop(chalk.green('Setup successfully completed'));
-            }
-            else {
-                setupSpinner.stop(chalk.yellow(`Setup ${setupFailedMessage ? 'failed' : 'timed out'} — proceeding without setup${setupFailedMessage ? ` (${setupFailedMessage})` : ''}`));
-            }
-        }
-        // Step 3 (optional): Prior to enqueue, detect and submit user edit diffs
-        if (options?.saveLocal) {
-            const prepSpinner = createSpinner('dots');
-            currentSpinner = prepSpinner;
-            prepSpinner.start('Updating translations...');
-            try {
-                await collectAndSendUserEditDiffs(upload.uploadedFiles, settings);
-            }
-            catch {
-                // Non-fatal; keep going to enqueue
-            }
-            finally {
-                prepSpinner.stop('Updated translations');
-            }
-        }
-        // Step 4: Enqueue translations by reference
-        const enqueueSpinner = createSpinner('dots');
-        currentSpinner = enqueueSpinner;
-        enqueueSpinner.start('Enqueuing translations...');
-        const enqueueResult = await gt.enqueueFiles(upload.uploadedFiles, {
-            sourceLocale: settings.defaultLocale,
-            targetLocales: settings.locales,
-            publish: settings.publish,
-            requireApproval: settings.stageTranslations,
-            modelProvider: settings.modelProvider,
-            force: options?.force,
-        });
-        const { data, message, locales, translations } = enqueueResult;
-        enqueueSpinner.stop(chalk.green('Files for translation uploaded successfully'));
-        logSuccess(message);
-        return { data, locales, translations };
-    }
-    catch {
-        if (currentSpinner) {
-            currentSpinner.stop();
-        }
-        logErrorAndExit('Failed to send files for translation');
-    }
-}

package/dist/api/sendUserEdits.d.ts

@@ -1,19 +0,0 @@
-import { Settings } from '../types/index.js';
-export type UserEditDiff = {
-    fileName: string;
-    locale: string;
-    diff: string;
-    versionId?: string;
-    fileId?: string;
-    localContent?: string;
-};
-export type SendUserEditsPayload = {
-    projectId?: string;
-    diffs: UserEditDiff[];
-};
-/**
- * Sends user edit diffs to the API for persistence/rule extraction.
- * This function is intentionally decoupled from the translate pipeline
- * so it can be called as an independent action.
- */
-export declare function sendUserEditDiffs(diffs: UserEditDiff[], settings: Settings): Promise<void>;

package/dist/api/sendUserEdits.js

@@ -1,15 +0,0 @@
-import { gt } from '../utils/gt.js';
-/**
- * Sends user edit diffs to the API for persistence/rule extraction.
- * This function is intentionally decoupled from the translate pipeline
- * so it can be called as an independent action.
- */
-export async function sendUserEditDiffs(diffs, settings) {
-    if (!diffs.length)
-        return;
-    const payload = {
-        projectId: settings.projectId,
-        diffs,
-    };
-    await gt.submitUserEditDiffs(payload);
-}

package/dist/cli/commands/edits.d.ts

@@ -1,8 +0,0 @@
-import { Settings } from '../../types/index.js';
-export type SendDiffsFlags = {
-    fileName: string;
-    locale: string;
-    old: string;
-    next: string;
-};
-export declare function handleSendDiffs(flags: SendDiffsFlags, settings: Settings): Promise<void>;

package/dist/cli/commands/edits.js

@@ -1,32 +0,0 @@
-import fs from 'node:fs';
-import { getGitUnifiedDiff } from '../../utils/gitDiff.js';
-import { sendUserEditDiffs } from '../../api/sendUserEdits.js';
-import { logErrorAndExit, logMessage } from '../../console/logging.js';
-export async function handleSendDiffs(flags, settings) {
-    const { fileName, locale, old, next } = flags;
-    if (!fs.existsSync(old)) {
-        logErrorAndExit(`Old/original file not found: ${old}`);
-    }
-    if (!fs.existsSync(next)) {
-        logErrorAndExit(`New/local file not found: ${next}`);
-    }
-    let diff;
-    try {
-        diff = await getGitUnifiedDiff(old, next);
-    }
-    catch (e) {
-        logErrorAndExit('Git is required to compute diffs. Please install Git and ensure it is available on your PATH.');
-        return; // unreachable
-    }
-    if (!diff || diff.trim().length === 0) {
-        logMessage('No differences detected — nothing to send.');
-        return;
-    }
-    await sendUserEditDiffs([
-        {
-            fileName,
-            locale,
-            diff,
-        },
-    ], settings);
-}

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

@@ -1,9 +0,0 @@
-import { NodePath } from '@babel/traverse';
-/**
- * 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' }
- */
-export declare function buildImportMap(programPath: NodePath): Map<string, string>;

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

@@ -1,30 +0,0 @@
-import * as t from '@babel/types';
-/**
- * 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' }
- */
-export 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;
-}

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

@@ -1,17 +0,0 @@
-import { NodePath } from '@babel/traverse';
-/**
- *
- */
-export declare function getPathsAndAliases(ast: any, pkg: 'gt-react' | 'gt-next'): {
-    importAliases: Record<string, string>;
-    inlineTranslationPaths: Array<{
-        localName: string;
-        path: NodePath;
-        originalName: string;
-    }>;
-    translationComponentPaths: Array<{
-        localName: string;
-        path: NodePath;
-        originalName: string;
-    }>;
-};

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

@@ -1,89 +0,0 @@
-import traverseModule from '@babel/traverse';
-import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_TRANSLATION_HOOK, TRANSLATION_COMPONENT, } from '../../jsx/utils/constants.js';
-import { extractImportName } from './parseAst.js';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
-/**
- *
- */
-export function getPathsAndAliases(ast, pkg) {
-    // First pass: collect imports and process translation functions
-    const importAliases = {};
-    const inlineTranslationPaths = [];
-    const translationComponentPaths = [];
-    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) {
-                        inlineTranslationPaths.push({
-                            localName: name.local,
-                            path,
-                            originalName: name.original,
-                        });
-                    }
-                    else if (name.original === TRANSLATION_COMPONENT) {
-                        translationComponentPaths.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) {
-                                inlineTranslationPaths.push({
-                                    localName: name.local,
-                                    path: parentPath,
-                                    originalName: name.original,
-                                });
-                            }
-                            else if (name.original === TRANSLATION_COMPONENT) {
-                                translationComponentPaths.push({
-                                    localName: name.local,
-                                    path: parentPath,
-                                    originalName: name.original,
-                                });
-                            }
-                            else {
-                                importAliases[name.local] = name.original;
-                            }
-                        }
-                    }
-                }
-            }
-        },
-    });
-    return {
-        importAliases,
-        inlineTranslationPaths,
-        translationComponentPaths,
-    };
-}

package/dist/react/jsx/utils/jsxParsing/handleChildrenWhitespace.d.ts

@@ -1,6 +0,0 @@
-import { JsxTree, MultiplicationNode, WhitespaceJsxTreeResult, WhitespaceMultiplicationNode } from './types.js';
-export declare function trimJsxStringChild(child: string, index: number, childrenTypes: ('expression' | 'text' | 'element' | 'multiplication' | 'other')[]): string;
-export declare function handleChildrenWhitespace(currentTree: MultiplicationNode['branches'], parentNodeType: 'multiplication'): (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
-export declare function handleChildrenWhitespace(currentTree: MultiplicationNode['branches'], parentNodeType?: 'element' | 'expression' | undefined): WhitespaceJsxTreeResult | WhitespaceMultiplicationNode | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
-export declare function handleChildrenWhitespace(currentTree: MultiplicationNode | JsxTree, parentNodeType?: 'multiplication' | 'element' | 'expression' | undefined): null | WhitespaceJsxTreeResult | WhitespaceMultiplicationNode;
-export declare function handleChildrenWhitespace(currentTree: JsxTree | JsxTree[]): null | WhitespaceJsxTreeResult | WhitespaceJsxTreeResult[];

package/dist/react/jsx/utils/jsxParsing/handleChildrenWhitespace.js

@@ -1,199 +0,0 @@
-import { isAcceptedPluralForm } from 'generaltranslation/internal';
-import { isElementNode, isExpressionNode, isMultiplicationNode, } from './types.js';
-// JSX whitespace characters (space, tab, newline, carriage return)
-// Does NOT include non-breaking space (U+00A0) which should be preserved
-const isJsxWhitespace = (char) => {
-    return char === ' ' || char === '\t' || char === '\n' || char === '\r';
-};
-const trimJsxWhitespace = (str, side = 'both') => {
-    let start = 0;
-    let end = str.length;
-    if (side === 'start' || side === 'both') {
-        while (start < end && isJsxWhitespace(str[start])) {
-            start++;
-        }
-    }
-    if (side === 'end' || side === 'both') {
-        while (end > start && isJsxWhitespace(str[end - 1])) {
-            end--;
-        }
-    }
-    return str.slice(start, end);
-};
-const hasNonJsxWhitespace = (str) => {
-    for (const char of str) {
-        if (!isJsxWhitespace(char))
-            return true;
-    }
-    return false;
-};
-export function trimJsxStringChild(child, index, childrenTypes) {
-    if (!child.includes('\n') && !child.includes('\r')) {
-        return child;
-    }
-    // Normalize line endings to \n for consistency across platforms
-    let result = child.replace(/\r\n|\r/g, '\n');
-    // Collapse multiple spaces/tabs into a single space (but not nbsp)
-    result = result.replace(/[\t ]+/g, ' ');
-    let newResult = '';
-    let newline = false;
-    for (const char of result) {
-        if (char === '\n') {
-            if (hasNonJsxWhitespace(newResult))
-                newResult += ' ';
-            else
-                newResult = '';
-            newline = true;
-            continue;
-        }
-        if (!newline) {
-            newResult += char;
-            continue;
-        }
-        if (isJsxWhitespace(char))
-            continue;
-        newResult += char;
-        newline = false;
-    }
-    if (newline)
-        newResult = trimJsxWhitespace(newResult, 'end');
-    result = newResult;
-    // Collapse multiple spaces/tabs into a single space (but not nbsp)
-    result = result.replace(/[\t ]+/g, ' ');
-    return result;
-}
-/**
- * Handles whitespace in children of a JSX element, and strips elements
- * @param currentTree - The current tree to handle
- * @returns The processed tree with whitespace handled
- *
- * For unresolved functions, we just make it so that Static has no children
- *
- * The typing was so much worse before this. Don't come for me. All I did was enforce the typing.
- */
-export function handleChildrenWhitespace(currentTree, parentNodeType = undefined) {
-    if (Array.isArray(currentTree)) {
-        const childrenTypes = currentTree.map((child) => {
-            if (typeof child === 'string')
-                return 'text';
-            if (isExpressionNode(child))
-                return 'expression';
-            if (isElementNode(child))
-                return 'element';
-            if (isMultiplicationNode(child))
-                return 'multiplication';
-            return 'other';
-        });
-        const newChildren = [];
-        currentTree.forEach((child, index) => {
-            switch (childrenTypes[index]) {
-                case 'text':
-                    const textNode = child;
-                    if (parentNodeType === 'multiplication') {
-                        // This should be treated like a new tree (no parent here b/c its a new tree)
-                        const result = handleChildrenWhitespace(textNode);
-                        if (result)
-                            newChildren.push(result);
-                    }
-                    else {
-                        const string = trimJsxStringChild(textNode, index, childrenTypes);
-                        if (string)
-                            newChildren.push(string);
-                    }
-                    break;
-                case 'expression':
-                    // Strip expressions
-                    const result = child.result;
-                    if (isMultiplicationNode(result)) {
-                        newChildren.push(handleChildrenWhitespace(result));
-                    }
-                    else if (typeof result === 'string') {
-                        newChildren.push(result);
-                    }
-                    else {
-                        // other case
-                        newChildren.push(result);
-                    }
-                    break;
-                case 'element':
-                    const newElement = handleChildrenWhitespace(child);
-                    newChildren.push(newElement);
-                    break;
-                case 'multiplication':
-                    // I dont think this case is possible, at least in the array case
-                    // Can only be child of element or multiplication nodes
-                    newChildren.push({
-                        nodeType: 'multiplication',
-                        branches: handleChildrenWhitespace(child.branches, 'multiplication'),
-                    });
-                    break;
-                case 'other':
-                    // Return number or boolean or null
-                    newChildren.push(child);
-                    break;
-            }
-        });
-        if (parentNodeType === 'multiplication') {
-            // Return the branches as an array
-            return newChildren;
-        }
-        return newChildren.length === 1 ? newChildren[0] : newChildren;
-    }
-    else if (isElementNode(currentTree)) {
-        // Process all props recursively
-        // What if there is a different component sharing the same name?
-        const elementIsPlural = currentTree.type === 'Plural';
-        const elementIsBranch = currentTree.type === 'Branch';
-        const processedProps = !currentTree.props
-            ? undefined
-            : Object.fromEntries(Object.entries(currentTree.props).map(([key, value]) => {
-                let shouldProcess = false;
-                // Process children
-                if (key === 'children')
-                    shouldProcess = true;
-                // Process plural children
-                if (elementIsPlural && isAcceptedPluralForm(key))
-                    shouldProcess = true;
-                // Process branch children
-                if (elementIsBranch && key !== 'branch')
-                    shouldProcess = true;
-                // Do not process raw strings
-                if (typeof value === 'string' && key !== 'children')
-                    shouldProcess = false;
-                // Process props
-                if (!shouldProcess) {
-                    return [key, value];
-                }
-                return [key, handleChildrenWhitespace(value)];
-            }));
-        return {
-            nodeType: 'element',
-            type: currentTree.type,
-            ...(processedProps ? { props: processedProps } : {}),
-        };
-    }
-    else if (isExpressionNode(currentTree)) {
-        // Strip expression
-        const result = currentTree.result;
-        if (isMultiplicationNode(result)) {
-            return handleChildrenWhitespace(result);
-        }
-        else if (typeof result === 'string') {
-            return result;
-        }
-        else {
-            return result;
-        }
-    }
-    else if (isMultiplicationNode(currentTree)) {
-        return {
-            nodeType: 'multiplication',
-            branches: handleChildrenWhitespace(currentTree.branches, 'multiplication'),
-        };
-    }
-    else if (typeof currentTree === 'string') {
-        return trimJsxStringChild(currentTree, 0, ['text']);
-    }
-    // null or number or boolean
-    return currentTree;
-}

package/dist/react/jsx/utils/jsxParsing/multiplication/findMultiplicationNode.d.ts

@@ -1,13 +0,0 @@
-import { WhitespaceJsxTreeResult, WhitespaceMultiplicationNode } from '../types.js';
-export type MultiplicationNodeResult = {
-    parent: any | undefined;
-    key: string | undefined;
-    node: WhitespaceMultiplicationNode;
-};
-/**
- * Finds the immediate multiplication node from the given root (eg no nested multiplication nodes)
- * TODO: I am sure there is some optimization to be done here
- *
- * Maybe there is an optimization here with caching used paths btwn calls
- */
-export declare function findMultiplicationNode(root: WhitespaceJsxTreeResult | WhitespaceMultiplicationNode | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[]): MultiplicationNodeResult | undefined;

package/dist/react/jsx/utils/jsxParsing/multiplication/findMultiplicationNode.js

@@ -1,42 +0,0 @@
-import { isWhitespaceMultiplicationNode, isWhitespaceJsxTree, } from '../types.js';
-/**
- * Finds the immediate multiplication node from the given root (eg no nested multiplication nodes)
- * TODO: I am sure there is some optimization to be done here
- *
- * Maybe there is an optimization here with caching used paths btwn calls
- */
-export function findMultiplicationNode(root) {
-    // Entry point
-    return handleChildren(root, undefined, undefined);
-    // Helper function to handle children
-    function handleChildren(curr, parent, key) {
-        if (Array.isArray(curr)) {
-            for (const [index, child] of Object.entries(curr)) {
-                const result = handleChild(child, parent, index);
-                if (result)
-                    return result;
-            }
-            return undefined;
-        }
-        else {
-            return handleChild(curr, parent, key);
-        }
-    }
-    // Helper function to handle a single child
-    function handleChild(curr, parent, key) {
-        if (isWhitespaceMultiplicationNode(curr)) {
-            return { parent, key, node: curr };
-        }
-        else if (isWhitespaceJsxTree(curr)) {
-            if (curr.props?.children) {
-                return handleChildren(curr.props.children, curr.props, 'children');
-            }
-            else {
-                return undefined;
-            }
-        }
-        else {
-            return undefined;
-        }
-    }
-}

package/dist/react/jsx/utils/jsxParsing/multiplication/multiplyJsxTree.d.ts

@@ -1,5 +0,0 @@
-import { MultipliedTreeNode, WhitespaceJsxTreeResult } from '../types.js';
-/**
- * Given a JSX tree, multiply the static function nodes
- */
-export declare function multiplyJsxTree(tree: WhitespaceJsxTreeResult | WhitespaceJsxTreeResult[]): MultipliedTreeNode[];