gtx-cli 2.6.31 → 2.7.0

package/dist/api/collectUserEditDiffs.js

@@ -1,159 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { getDownloadedVersions } from '../fs/config/downloadedVersions.js';
-import { createFileMapping } from '../formats/files/fileMapping.js';
-import { getGitUnifiedDiff } from '../utils/gitDiff.js';
-import { gt } from '../utils/gt.js';
-import os from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { hashStringSync } from '../utils/hash.js';
-import { extractJson } from '../formats/json/extractJson.js';
-const findLatestDownloadedVersion = (downloadedVersions, branchId, fileId, locale) => {
-    const versionsForFile = downloadedVersions.entries?.[branchId]?.[fileId] ?? undefined;
-    if (!versionsForFile)
-        return null;
-    let latest = null;
-    for (const [versionId, locales] of Object.entries(versionsForFile)) {
-        const entry = locales?.[locale];
-        if (!entry)
-            continue;
-        const updatedAt = entry.updatedAt
-            ? Date.parse(entry.updatedAt)
-            : Number.NEGATIVE_INFINITY;
-        const latestUpdatedAt = latest?.entry.updatedAt
-            ? Date.parse(latest.entry.updatedAt)
-            : Number.NEGATIVE_INFINITY;
-        if (!latest || updatedAt > latestUpdatedAt) {
-            latest = { versionId, entry };
-        }
-    }
-    return latest;
-};
-/**
- * Collects local user edits by diffing the latest downloaded server translation version
- * against the current local translation file, and submits the diffs upstream.
- *
- * Must run before enqueueing new translations so rules are available to the generator.
- */
-export async function collectAndSendUserEditDiffs(files, settings) {
-    if (!settings.files)
-        return;
-    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
-    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-    const downloadedVersions = getDownloadedVersions(settings.configDirectory);
-    const tempDir = path.join(os.tmpdir(), randomUUID());
-    if (!fs.existsSync(tempDir))
-        fs.mkdirSync(tempDir, { recursive: true });
-    const candidates = [];
-    for (const uploadedFile of files) {
-        for (const locale of settings.locales) {
-            const outputPath = fileMapping[locale]?.[uploadedFile.fileName] ?? null;
-            if (!outputPath)
-                continue;
-            if (!fs.existsSync(outputPath))
-                continue;
-            const latestDownloaded = findLatestDownloadedVersion(downloadedVersions, uploadedFile.branchId, uploadedFile.fileId, locale);
-            if (!latestDownloaded)
-                continue;
-            const downloadedVersion = latestDownloaded.entry;
-            // Skip if local file matches the last postprocessed content hash
-            if (downloadedVersion.postProcessHash) {
-                try {
-                    const localContent = await fs.promises.readFile(outputPath, 'utf8');
-                    const localHash = hashStringSync(localContent);
-                    if (localHash === downloadedVersion.postProcessHash) {
-                        continue;
-                    }
-                }
-                catch {
-                    // If hash check fails, fall through to diff
-                }
-            }
-            candidates.push({
-                branchId: uploadedFile.branchId,
-                fileName: uploadedFile.fileName,
-                fileId: uploadedFile.fileId,
-                versionId: latestDownloaded.versionId,
-                locale: locale,
-                outputPath,
-            });
-        }
-    }
-    const collectedDiffs = [];
-    if (candidates.length > 0) {
-        const fileQueryData = candidates.map((c) => ({
-            versionId: c.versionId,
-            locale: c.locale,
-            fileId: c.fileId,
-            branchId: c.branchId,
-        }));
-        // Single batched check to obtain translation IDs
-        const checkResponse = await gt.queryFileData({
-            translatedFiles: fileQueryData,
-        });
-        const translatedFiles = checkResponse.translatedFiles?.filter((t) => t.completedAt) ?? [];
-        const serverContentByKey = new Map();
-        try {
-            const resp = await gt.downloadFileBatch(translatedFiles.map((file) => ({
-                branchId: file.branchId,
-                fileId: file.fileId,
-                locale: file.locale,
-                versionId: file.versionId,
-            })));
-            const files = resp?.files || [];
-            for (const f of files) {
-                serverContentByKey.set(`${f.branchId}:${f.fileId}:${f.versionId}:${f.locale}`, f.data);
-            }
-        }
-        catch {
-            // Ignore chunk failures; proceed with what we have
-        }
-        // Compute diffs using fetched server contents
-        for (const c of candidates) {
-            const key = `${c.branchId}:${c.fileId}:${c.versionId}:${c.locale}`;
-            const serverContent = serverContentByKey.get(key);
-            if (!serverContent)
-                continue;
-            try {
-                const safeName = Buffer.from(`${c.branchId}:${c.fileId}:${c.versionId}:${c.locale}`)
-                    .toString('base64')
-                    .replace(/=+$/g, '');
-                const tempServerFile = path.join(tempDir, `${safeName}.server`);
-                await fs.promises.writeFile(tempServerFile, serverContent, 'utf8');
-                const diff = await getGitUnifiedDiff(tempServerFile, c.outputPath);
-                try {
-                    await fs.promises.unlink(tempServerFile);
-                }
-                catch { }
-                if (diff && diff.trim().length > 0) {
-                    const rawLocalContent = await fs.promises.readFile(c.outputPath, 'utf8');
-                    // For JSON files with jsonSchema config, extract to composite format
-                    let localContent = rawLocalContent;
-                    if (c.fileName.endsWith('.json') &&
-                        settings.options?.jsonSchema &&
-                        c.locale !== settings.defaultLocale) {
-                        const extractedContent = extractJson(rawLocalContent, c.fileName, settings.options, c.locale, settings.defaultLocale);
-                        if (extractedContent) {
-                            localContent = extractedContent;
-                        }
-                    }
-                    collectedDiffs.push({
-                        fileName: c.fileName,
-                        locale: c.locale,
-                        diff,
-                        branchId: c.branchId,
-                        versionId: c.versionId,
-                        fileId: c.fileId,
-                        localContent,
-                    });
-                }
-            }
-            catch {
-                // Ignore failures for this file
-            }
-        }
-    }
-    if (collectedDiffs.length > 0) {
-        await gt.submitUserEditDiffs({ diffs: collectedDiffs });
-    }
-}

package/dist/api/downloadFileBatch.d.ts

@@ -1,23 +0,0 @@
-import { Settings } from '../types/index.js';
-import type { FileStatusTracker } from '../workflows/steps/PollJobsStep.js';
-export type BatchedFiles = {
-    branchId: string;
-    fileId: string;
-    versionId: string;
-    locale: string;
-    outputPath: string;
-    inputPath: string;
-}[];
-export type DownloadFileBatchResult = {
-    successful: BatchedFiles;
-    failed: BatchedFiles;
-    skipped: BatchedFiles;
-};
-/**
- * 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 declare function downloadFileBatch(fileTracker: FileStatusTracker, files: BatchedFiles, options: Settings, forceDownload?: boolean): Promise<DownloadFileBatchResult>;

package/dist/api/downloadFileBatch.js

@@ -1,190 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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/cli/base.d.ts

@@ -1,59 +0,0 @@
-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>;
-}