gt 0.10.0 → 2.7.0

package/dist/api/downloadFileBatch.js

@@ -0,0 +1,190 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { logger } from '../console/logger.js';
+import { gt } from '../utils/gt.js';
+import { validateJsonSchema } from '../formats/json/utils.js';
+import { validateYamlSchema } from '../formats/yaml/utils.js';
+import { mergeJson } from '../formats/json/mergeJson.js';
+import mergeYaml from '../formats/yaml/mergeYaml.js';
+import { getDownloadedVersions, saveDownloadedVersions, ensureNestedObject, } from '../fs/config/downloadedVersions.js';
+import { recordDownloaded } from '../state/recentDownloads.js';
+import { recordWarning } from '../state/translateWarnings.js';
+import { hashStringSync } from '../utils/hash.js';
+import stringify from 'fast-json-stable-stringify';
+/**
+ * Downloads multiple translation files in a single batch request
+ * @param files - Array of files to download with their output paths
+ * @param maxRetries - Maximum number of retry attempts
+ * @param retryDelay - Delay between retries in milliseconds
+ * @returns Object containing successful and failed file IDs
+ */
+export async function downloadFileBatch(fileTracker, files, options, forceDownload = false) {
+    // Local record of what version was last downloaded for each fileName:locale
+    const downloadedVersions = getDownloadedVersions(options.configDirectory);
+    let didUpdateDownloadedLock = false;
+    // Create a map of requested file keys to the file object
+    const requestedFileMap = new Map(files.map((file) => [
+        `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`,
+        file,
+    ]));
+    const result = {
+        successful: [],
+        failed: [],
+        skipped: [],
+    };
+    // Create a map of translationId to outputPath for easier lookup
+    const outputPathMap = new Map(files.map((file) => [
+        `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`,
+        file.outputPath,
+    ]));
+    try {
+        // Download the files
+        const responseData = await gt.downloadFileBatch(files.map((file) => ({
+            fileId: file.fileId,
+            branchId: file.branchId,
+            versionId: file.versionId,
+            locale: file.locale,
+        })));
+        const downloadedFiles = responseData.files || [];
+        // Process each file in the response
+        for (const file of downloadedFiles) {
+            const fileKey = `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`;
+            const requestedFile = requestedFileMap.get(fileKey);
+            if (!requestedFile) {
+                continue;
+            }
+            try {
+                const outputPath = outputPathMap.get(fileKey);
+                const fileProperties = fileTracker.completed.get(fileKey);
+                if (!outputPath || !fileProperties) {
+                    logger.warn(`No input/output path found for file: ${fileKey}`);
+                    recordWarning('failed_download', fileKey, 'No input/output path found');
+                    result.failed.push(requestedFile);
+                    continue;
+                }
+                const { fileId, versionId, locale, branchId, fileName: inputPath, } = fileProperties;
+                // Ensure the directory exists
+                const dir = path.dirname(outputPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                // If a local translation already exists for the same source version, skip overwrite
+                const downloadedVersion = downloadedVersions.entries[branchId]?.[fileId]?.[versionId]?.[locale];
+                const fileExists = fs.existsSync(outputPath);
+                let sourceChanged = false;
+                if (downloadedVersion?.sourceHash) {
+                    try {
+                        const currentSourceContent = fs.readFileSync(inputPath, 'utf8');
+                        const currentSourceHash = hashStringSync(currentSourceContent);
+                        sourceChanged = currentSourceHash !== downloadedVersion.sourceHash;
+                    }
+                    catch {
+                        sourceChanged = true;
+                    }
+                }
+                if (!forceDownload &&
+                    !sourceChanged &&
+                    fileExists &&
+                    downloadedVersion) {
+                    result.skipped.push(requestedFile);
+                    continue;
+                }
+                let data = file.data;
+                let sourceContentHash;
+                if (options.options?.jsonSchema && locale) {
+                    const jsonSchema = validateJsonSchema(options.options, inputPath);
+                    if (jsonSchema) {
+                        const originalContent = fs.readFileSync(inputPath, 'utf8');
+                        if (originalContent) {
+                            sourceContentHash = hashStringSync(originalContent);
+                            data = mergeJson(originalContent, inputPath, options.options, [
+                                {
+                                    translatedContent: file.data,
+                                    targetLocale: locale,
+                                },
+                            ], options.defaultLocale, options.locales)[0];
+                        }
+                    }
+                }
+                if (options.options?.yamlSchema && locale) {
+                    const yamlSchema = validateYamlSchema(options.options, inputPath);
+                    if (yamlSchema) {
+                        const originalContent = fs.readFileSync(inputPath, 'utf8');
+                        if (originalContent) {
+                            sourceContentHash = hashStringSync(originalContent);
+                            data = mergeYaml(originalContent, inputPath, options.options, [
+                                {
+                                    translatedContent: file.data,
+                                    targetLocale: locale,
+                                },
+                            ], options.defaultLocale)[0];
+                        }
+                    }
+                }
+                // If the file is a GTJSON file, stable sort the order and format the data
+                if (file.fileFormat === 'GTJSON') {
+                    try {
+                        const jsonData = JSON.parse(data);
+                        const sortedData = stringify(jsonData); // stably sort with fast-json-stable-stringify
+                        const sortedJsonData = JSON.parse(sortedData);
+                        data = JSON.stringify(sortedJsonData, null, 2); // format the data
+                    }
+                    catch (error) {
+                        logger.warn(`Failed to sort GTJson file: ${file.id}: ` + error);
+                    }
+                }
+                // Write the file to disk
+                await fs.promises.writeFile(outputPath, data);
+                // Track as downloaded with metadata for downstream postprocessing
+                recordDownloaded(outputPath, {
+                    branchId,
+                    fileId,
+                    versionId,
+                    locale,
+                    inputPath,
+                });
+                result.successful.push(requestedFile);
+                if (branchId && fileId && versionId && locale) {
+                    ensureNestedObject(downloadedVersions.entries, [
+                        branchId,
+                        fileId,
+                        versionId,
+                        locale,
+                    ]);
+                    downloadedVersions.entries[branchId][fileId][versionId][locale] = {
+                        updatedAt: new Date().toISOString(),
+                        ...(sourceContentHash ? { sourceHash: sourceContentHash } : {}),
+                    };
+                    didUpdateDownloadedLock = true;
+                }
+            }
+            catch (error) {
+                logger.error(`Error saving file ${fileKey}: ` + error);
+                recordWarning('failed_download', fileKey, `Error saving file: ${error}`);
+                result.failed.push(requestedFile);
+            }
+        }
+        // Add any files that weren't in the response to the failed list
+        const downloadedFileKeys = new Set(downloadedFiles.map((file) => `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`));
+        for (const [fileKey, requestedFile] of requestedFileMap.entries()) {
+            if (!downloadedFileKeys.has(fileKey)) {
+                result.failed.push(requestedFile);
+            }
+        }
+        // Persist any updates to the downloaded map at the end of a successful cycle
+        if (didUpdateDownloadedLock) {
+            saveDownloadedVersions(options.configDirectory, downloadedVersions);
+            didUpdateDownloadedLock = false;
+        }
+        return result;
+    }
+    catch (error) {
+        logger.error(`An unexpected error occurred while downloading files: ` + error);
+    }
+    // Mark all files as failed if we get here
+    result.failed = [...requestedFileMap.values()];
+    if (didUpdateDownloadedLock) {
+        saveDownloadedVersions(options.configDirectory, downloadedVersions);
+    }
+    return result;
+}

package/dist/api/saveLocalEdits.d.ts

@@ -0,0 +1,6 @@
+import { Settings } from '../types/index.js';
+/**
+ * Uploads current source files to obtain file references, then collects and sends
+ * diffs for all locales based on last downloaded versions. Does not enqueue translations.
+ */
+export declare function saveLocalEdits(settings: Settings): Promise<void>;

package/dist/api/saveLocalEdits.js

@@ -0,0 +1,38 @@
+import { aggregateFiles } from '../formats/files/aggregateFiles.js';
+import { collectAndSendUserEditDiffs } from './collectUserEditDiffs.js';
+import { gt } from '../utils/gt.js';
+import { BranchStep } from '../workflows/steps/BranchStep.js';
+import { logErrorAndExit } from '../console/logging.js';
+import { logger } from '../console/logger.js';
+import chalk from 'chalk';
+/**
+ * Uploads current source files to obtain file references, then collects and sends
+ * diffs for all locales based on last downloaded versions. Does not enqueue translations.
+ */
+export async function saveLocalEdits(settings) {
+    if (!settings.files)
+        return;
+    // Collect current files from config
+    const files = await aggregateFiles(settings);
+    if (!files.length)
+        return;
+    // run branch query to get branch id
+    // Run the branch step
+    const branchStep = new BranchStep(gt, settings);
+    const branchResult = await branchStep.run();
+    await branchStep.wait();
+    if (!branchResult) {
+        return logErrorAndExit('Failed to resolve git branch information.');
+    }
+    const uploads = files.map((file) => ({
+        fileName: file.fileName,
+        fileFormat: file.fileFormat,
+        branchId: branchResult.currentBranch.id,
+        fileId: file.fileId,
+        versionId: file.versionId,
+    }));
+    const spinner = logger.createSpinner('dots');
+    spinner.start('Saving local edits...');
+    await collectAndSendUserEditDiffs(uploads, settings);
+    spinner.stop(chalk.green('Local edits saved successfully'));
+}

package/dist/bin/bin-entry.d.ts

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

package/dist/bin/bin-entry.js

@@ -0,0 +1,9 @@
+// Entry point for binaries
+import { main } from '../index.js';
+import dotenv from 'dotenv';
+import { program } from 'commander';
+dotenv.config({ path: '.env' });
+dotenv.config({ path: '.env.local', override: true });
+dotenv.config({ path: '.env.production', override: true });
+main(program);
+program.parse();

package/dist/bin/bin-main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/bin-main.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// Routes to proper binary based on platform
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync, chmodSync, statSync } from 'fs';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function detectPlatform() {
+    const platform = process.platform;
+    const arch = process.arch;
+    // Map Node.js platform/arch to our binary names
+    const platformMap = {
+        darwin: {
+            x64: 'gt-darwin-x64',
+            arm64: 'gt-darwin-arm64',
+        },
+        linux: {
+            x64: 'gt-linux-x64',
+            arm64: 'gt-linux-arm64',
+        },
+        win32: {
+            x64: 'gt-win32-x64.exe',
+        },
+    };
+    return platformMap[platform]?.[arch] || null;
+}
+function routeToBinary() {
+    const binaryName = detectPlatform();
+    if (!binaryName) {
+        console.error(`Unsupported platform: ${process.platform}-${process.arch}`);
+        process.exit(1);
+    }
+    const binaryPath = join(__dirname, '..', '..', 'binaries', binaryName);
+    if (!existsSync(binaryPath)) {
+        console.error(`Binary not found at: ${binaryPath}`);
+        process.exit(1);
+    }
+    // Check and fix execute permissions if needed (Unix-like systems only)
+    if (process.platform !== 'win32') {
+        try {
+            const stats = statSync(binaryPath);
+            const isExecutable = !!(stats.mode & parseInt('100', 8)); // Check owner execute bit
+            if (!isExecutable) {
+                chmodSync(binaryPath, 0o755); // Make executable
+            }
+        }
+        catch (error) {
+            // If we can't check/fix permissions, continue anyway
+            // The spawn might still work or give a more meaningful error
+        }
+    }
+    // Spawn the appropriate binary with all arguments
+    const child = spawn(binaryPath, process.argv.slice(2), {
+        stdio: 'inherit',
+    });
+    child.on('close', (code) => {
+        // code might be null
+        process.exit(code ?? 1);
+    });
+    child.on('error', () => {
+        process.exit(1);
+    });
+    return;
+}
+// Entry point
+routeToBinary();

package/dist/cli/base.d.ts

@@ -0,0 +1,59 @@
+import { Command } from 'commander';
+import { Settings, SupportedLibraries, TranslateFlags } from '../types/index.js';
+export type UploadOptions = {
+    config?: string;
+    apiKey?: string;
+    projectId?: string;
+    defaultLocale?: string;
+};
+export type LoginOptions = {
+    keyType?: 'development' | 'production';
+};
+export declare class BaseCLI {
+    protected library: SupportedLibraries;
+    protected additionalModules: SupportedLibraries[];
+    protected program: Command;
+    constructor(program: Command, library: SupportedLibraries, additionalModules?: SupportedLibraries[]);
+    init(): void;
+    execute(): void;
+    protected setupSetupProjectCommand(): void;
+    protected setupStageCommand(): void;
+    /**
+     * Enqueues translations for a given set of files
+     * @param initOptions - The options for the command
+     * @returns The results of the command
+     */
+    protected setupEnqueueCommand(): void;
+    /**
+     * Downloads translations that were originally staged
+     * @param initOptions - The options for the command
+     * @returns The results of the command
+     */
+    protected setupDownloadCommand(): void;
+    protected setupTranslateCommand(): void;
+    protected setupSendDiffsCommand(): void;
+    protected handleSetupProject(initOptions: TranslateFlags): Promise<void>;
+    protected handleStage(initOptions: TranslateFlags): Promise<void>;
+    /**
+     * Enqueues translations for a given set of files
+     * @param initOptions - The options for the command
+     * @returns The results of the command
+     */
+    protected handleEnqueue(initOptions: TranslateFlags): Promise<void>;
+    /**
+     * Downloads translations that were originally staged
+     * @param initOptions - The options for the command
+     * @returns The results of the command
+     */
+    protected handleDownload(initOptions: TranslateFlags): Promise<void>;
+    protected handleTranslate(initOptions: TranslateFlags): Promise<void>;
+    protected setupUploadCommand(): void;
+    protected setupLoginCommand(): void;
+    protected setupInitCommand(): void;
+    protected setupConfigureCommand(): void;
+    protected handleUploadCommand(settings: Settings & UploadOptions): Promise<void>;
+    protected handleInitCommand(ranReactSetup: boolean, useDefaults?: boolean): Promise<void>;
+    protected handleLoginCommand(options: LoginOptions): Promise<void>;
+    protected setupUpdateInstructionsCommand(): void;
+    protected promptAgentInstructions(useDefaults?: boolean): Promise<void>;
+}