gtx-cli 2.1.5-alpha.5 → 2.1.5-alpha.6

package/dist/formats/files/upload.js

@@ -1,9 +1,6 @@
 import { noSupportedFormatError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, } from '../../console/index.js';
-import { logErrorAndExit, createSpinner, logError, } from '../../console/logging.js';
+import { logErrorAndExit, logError } from '../../console/logging.js';
 import { getRelative, readFile } from '../../fs/findFilepath.js';
-import chalk from 'chalk';
-import { downloadFile } from '../../api/downloadFile.js';
-import { downloadFileBatch } from '../../api/downloadFileBatch.js';
 import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
 import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
 import { parseJson } from '../json/parseJson.js';
@@ -139,74 +136,3 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
         logErrorAndExit(`Error uploading files: ${error}`);
     }
 }
-/**
- * Processes translations that were already completed and returned with the initial API response
- * @returns Set of downloaded file+locale combinations
- */
-async function processInitialTranslations(translations = [], fileMapping, options) {
-    const downloadStatus = {
-        downloaded: new Set(),
-        failed: new Set(),
-    };
-    if (!translations || translations.length === 0) {
-        return downloadStatus;
-    }
-    // Filter for ready translations
-    const readyTranslations = translations.filter((translation) => translation.isReady && translation.fileName);
-    if (readyTranslations.length > 0) {
-        const spinner = createSpinner('dots');
-        spinner.start('Downloading translations...');
-        // Prepare batch download data
-        const batchFiles = readyTranslations
-            .map((translation) => {
-            const { locale, fileName, id } = translation;
-            const outputPath = fileMapping[locale][fileName];
-            if (!outputPath) {
-                return null;
-            }
-            return {
-                translationId: id,
-                outputPath,
-                inputPath: fileName,
-                fileLocale: `${fileName}:${locale}`,
-                locale,
-            };
-        })
-            .filter(Boolean);
-        if (batchFiles.length === 0 || batchFiles[0] === null) {
-            return downloadStatus;
-        }
-        // Use batch download if there are multiple files
-        if (batchFiles.length > 1) {
-            const batchResult = await downloadFileBatch(batchFiles.map(({ translationId, outputPath, inputPath, locale }) => ({
-                translationId,
-                outputPath,
-                inputPath,
-                locale,
-            })), options);
-            // Process results
-            batchFiles.forEach((file) => {
-                const { translationId, fileLocale } = file;
-                if (batchResult.successful.includes(translationId)) {
-                    downloadStatus.downloaded.add(fileLocale);
-                }
-                else if (batchResult.failed.includes(translationId)) {
-                    downloadStatus.failed.add(fileLocale);
-                }
-            });
-        }
-        else if (batchFiles.length === 1) {
-            // For a single file, use the original downloadFile method
-            const file = batchFiles[0];
-            const result = await downloadFile(file.translationId, file.outputPath, file.inputPath, file.locale, options);
-            if (result) {
-                downloadStatus.downloaded.add(file.fileLocale);
-            }
-            else {
-                downloadStatus.failed.add(file.fileLocale);
-            }
-        }
-        spinner.stop(chalk.green('Downloaded cached translations'));
-    }
-    return downloadStatus;
-}

package/dist/formats/gt/save.d.ts

@@ -1,10 +1,9 @@
 import { RetrievedTranslations } from 'generaltranslation/types';
 import { ResolvedFiles } from '../../types/index.js';
-import { DataFormat } from '../../types/data.js';
 /**
  * Saves translations to a local directory
  * @param translations - The translations to save
  * @param translationsDir - The directory to save the translations to
  * @param fileType - The file type to save the translations as (file extension)
  */
-export declare function saveTranslations(translations: RetrievedTranslations, placeholderPaths: ResolvedFiles, dataFormat: DataFormat): Promise<void>;
+export declare function saveTranslations(translations: RetrievedTranslations, placeholderPaths: ResolvedFiles): Promise<void>;

package/dist/formats/gt/save.js

@@ -9,7 +9,7 @@ import { resolveLocaleFiles } from '../../fs/config/parseFilesConfig.js';
  * @param translationsDir - The directory to save the translations to
  * @param fileType - The file type to save the translations as (file extension)
  */
-export async function saveTranslations(translations, placeholderPaths, dataFormat) {
+export async function saveTranslations(translations, placeholderPaths) {
     for (const translation of translations) {
         const locale = translation.locale;
         const translationFiles = resolveLocaleFiles(placeholderPaths, locale);
@@ -21,9 +21,6 @@ export async function saveTranslations(translations, placeholderPaths, dataForma
         const translationData = translation.translation;
         // Ensure directory exists
         await fs.promises.mkdir(path.dirname(filepath), { recursive: true });
-        // Handle different file types
-        if (dataFormat === 'JSX') {
-            await fs.promises.writeFile(filepath, JSON.stringify(translationData, null, 2));
-        }
+        await fs.promises.writeFile(filepath, JSON.stringify(translationData, null, 2));
     }
 }

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

@@ -13,4 +13,5 @@ export declare function createOrUpdateConfig(configFilepath: string, options: {
     files?: FilesOptions;
     framework?: SupportedFrameworks;
     baseUrl?: string;
+    publish?: boolean;
 }): Promise<string>;

package/dist/fs/config/setupConfig.js

@@ -17,6 +17,7 @@ export async function createOrUpdateConfig(configFilepath, options) {
         ...(options.files && { files: options.files }),
         ...(options.framework && { framework: options.framework }),
         ...(options.baseUrl && { baseUrl: options.baseUrl }),
+        ...(options.publish && { publish: options.publish }),
     };
     try {
         // if file exists

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

@@ -2,10 +2,9 @@
  * Update the config file version id, locales, and projectId (if necessary)
  * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
  */
-export default function updateConfig({ configFilepath, projectId, _versionId, locales, stageTranslations, }: {
+export default function updateConfig({ configFilepath, projectId, _versionId, stageTranslations, }: {
     configFilepath: string;
     projectId?: string;
     _versionId?: string;
-    locales?: string[];
     stageTranslations?: boolean;
 }): Promise<void>;

package/dist/fs/config/updateConfig.js

@@ -5,7 +5,7 @@ import { logError } from '../../console/logging.js';
  * Update the config file version id, locales, and projectId (if necessary)
  * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
  */
-export default async function updateConfig({ configFilepath, projectId, _versionId, locales, stageTranslations, }) {
+export default async function updateConfig({ configFilepath, projectId, _versionId, stageTranslations, }) {
     // Filter out empty string values from the config object
     const newContent = {
         ...(projectId && { projectId }),

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

@@ -0,0 +1,10 @@
+type StagedVersionData = Record<string, {
+    fileName: string;
+    versionId: string;
+}>;
+export declare function updateVersions({ configDirectory, versionData, }: {
+    configDirectory: string;
+    versionData: StagedVersionData;
+}): Promise<void>;
+export declare function getStagedVersions(configDirectory: string): Promise<StagedVersionData>;
+export {};

package/dist/fs/config/updateVersions.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import { displayUpdatedVersionsFile } from '../../console/logging.js';
+import { logError } from '../../console/logging.js';
+import path from 'node:path';
+const STAGED_VERSIONS_FILE = 'staged-versions.json';
+// Update the versions.json file with the new version ids
+// of the translations that were sent to the API
+export async function updateVersions({ configDirectory, versionData, }) {
+    const versionFilepath = path.join(configDirectory, STAGED_VERSIONS_FILE);
+    try {
+        fs.mkdirSync(configDirectory, { recursive: true });
+        fs.writeFileSync(versionFilepath, JSON.stringify(versionData, null, 2));
+        // show update in console
+        displayUpdatedVersionsFile(versionFilepath);
+    }
+    catch (error) {
+        logError(`An error occurred while updating ${versionFilepath}: ${error}`);
+    }
+}
+export async function getStagedVersions(configDirectory) {
+    try {
+        const versionFilepath = path.join(configDirectory, STAGED_VERSIONS_FILE);
+        const versionData = JSON.parse(fs.readFileSync(versionFilepath, 'utf8'));
+        return versionData;
+    }
+    catch (error) {
+        logError(`An error occurred while getting staged versions: ${error}`);
+        return {};
+    }
+}

package/dist/fs/copyFile.d.ts

@@ -1,8 +1,7 @@
 import { Settings } from '../types/index.js';
-import { TranslateOptions } from '../cli/base.js';
 /**
  * Copy a file to target locale without translation
  *
  * This is a naive approach, does not allow for wild cards
  */
-export default function copyFile(settings: Settings & TranslateOptions): Promise<void>;
+export default function copyFile(settings: Settings): Promise<void>;

package/dist/translation/parse.d.ts

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

package/dist/translation/parse.js

@@ -48,12 +48,10 @@ export async function createUpdates(options, sourceDictionary, pkg, validate) {
         }
     }
     // Scan through project for <T> tags
-    if (options.inline) {
-        const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, options.src);
-        errors = [...errors, ...newErrors];
-        warnings = [...warnings, ...newWarnings];
-        updates = [...updates, ...newUpdates];
-    }
+    const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, options.src);
+    errors = [...errors, ...newErrors];
+    warnings = [...warnings, ...newWarnings];
+    updates = [...updates, ...newUpdates];
     // Metadata addition and validation
     const idHashMap = new Map();
     const duplicateIds = new Set();

package/dist/translation/stage.d.ts

@@ -1,5 +1,2 @@
-import { Options, Settings } from '../types/index.js';
-export declare function stageProject(settings: Options & Settings, pkg: 'gt-react' | 'gt-next'): Promise<{
-    versionId: string;
-    locales: string[];
-} | null>;
+import { Settings, TranslateFlags, Updates } from '../types/index.js';
+export declare function aggregateReactTranslations(options: TranslateFlags, settings: Settings, library: 'gt-react' | 'gt-next'): Promise<Updates>;

package/dist/translation/stage.js

@@ -1,14 +1,11 @@
-import { devApiKeyError } from '../console/index.js';
 import { logErrorAndExit } from '../console/logging.js';
 import chalk from 'chalk';
 import findFilepath from '../fs/findFilepath.js';
-import { logSuccess, logWarning, logError } from '../console/logging.js';
+import { logWarning, logError } from '../console/logging.js';
 import { createUpdates } from './parse.js';
-import { noLocalesError, noDefaultLocaleError, noProjectIdError, noApiKeyError, } from '../console/index.js';
-import { sendUpdates } from '../api/sendUpdates.js';
-export async function stageProject(settings, pkg) {
-    if (!settings.dictionary) {
-        settings.dictionary = findFilepath([
+export async function aggregateReactTranslations(options, settings, library) {
+    if (!options.dictionary) {
+        options.dictionary = findFilepath([
             './dictionary.js',
             './src/dictionary.js',
             './dictionary.json',
@@ -17,29 +14,16 @@ export async function stageProject(settings, pkg) {
             './src/dictionary.ts',
         ]);
     }
-    // Separate defaultLocale from locales
-    settings.locales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
-    // validate timeout
-    const timeout = parseInt(settings.timeout);
-    if (isNaN(timeout) || timeout < 0) {
-        logErrorAndExit(`Invalid timeout: ${settings.timeout}. Must be a positive integer.`);
-    }
-    settings.timeout = timeout.toString();
     // ---- CREATING UPDATES ---- //
-    const { updates, errors, warnings } = await createUpdates(settings, settings.dictionary, pkg, false);
+    const { updates, errors, warnings } = await createUpdates(options, options.dictionary, library, false);
     if (warnings.length > 0) {
-        if (settings.suppressWarnings) {
-            logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To view these warnings, re-run without the --suppress-warnings flag')}`));
-        }
-        else {
-            logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To suppress these warnings, re-run with --suppress-warnings')}\n` +
-                warnings
-                    .map((warning) => chalk.yellow('• Warning: ') + chalk.white(warning))
-                    .join('\n')));
-        }
+        logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content.\n` +
+            warnings
+                .map((warning) => chalk.yellow('• Warning: ') + chalk.white(warning))
+                .join('\n')));
     }
     if (errors.length > 0) {
-        if (settings.ignoreErrors) {
+        if (options.ignoreErrors) {
             logWarning(chalk.yellow(`Warning: CLI tool encountered ${errors.length} syntax errors while scanning for translatable content. These components will not be translated.\n` +
                 errors
                     .map((error) => chalk.yellow('• ') + chalk.white(error) + '\n')
@@ -52,35 +36,9 @@ export async function stageProject(settings, pkg) {
                     .join('')));
         }
     }
-    if (settings.dryRun) {
-        logSuccess('Dry run: No translations were sent to General Translation.');
-        return null;
-    }
     if (updates.length == 0) {
-        logError(chalk.red(`No in-line content or dictionaries were found for ${chalk.green(pkg)}. Are you sure you're running this command in the right directory?`));
-        return null;
-    }
-    // Send updates to General Translation API
-    if (!settings.locales) {
-        logErrorAndExit(noLocalesError);
-    }
-    if (!settings.defaultLocale) {
-        logErrorAndExit(noDefaultLocaleError);
-    }
-    if (!settings.apiKey) {
-        logErrorAndExit(noApiKeyError);
-    }
-    if (settings.apiKey.startsWith('gtx-dev-')) {
-        logErrorAndExit(devApiKeyError);
-    }
-    if (!settings.projectId) {
-        logErrorAndExit(noProjectIdError);
+        logError(chalk.red(`No in-line content or dictionaries were found for ${chalk.green(library)}. Are you sure you're running this command in the right directory?`));
+        return updates;
     }
-    const updateResponse = await sendUpdates(updates, {
-        ...settings,
-        timeout: settings.timeout,
-        dataFormat: 'JSX',
-    }, pkg);
-    const { versionId, locales } = updateResponse;
-    return { versionId, locales };
+    return updates;
 }

package/dist/types/files.d.ts

@@ -0,0 +1 @@
+export type FileMapping = Record<string, Record<string, string>>;

package/dist/types/files.js

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

package/dist/types/index.d.ts

@@ -15,13 +15,35 @@ export type Options = {
     ignoreErrors: boolean;
     suppressWarnings: boolean;
     dryRun: boolean;
-    timeout: string;
+    timeout: number;
     stageTranslations?: boolean;
     experimentalLocalizeStaticUrls?: boolean;
     experimentalHideDefaultLocale?: boolean;
     experimentalFlattenJsonFiles?: boolean;
     experimentalLocalizeStaticImports?: boolean;
 };
+export type TranslateFlags = {
+    config?: string;
+    apiKey?: string;
+    projectId?: string;
+    versionId?: string;
+    jsconfig?: string;
+    dictionary?: string;
+    defaultLocale?: string;
+    locales?: string[];
+    ignoreErrors?: boolean;
+    src?: string[];
+    timeout: number;
+    dryRun: boolean;
+    stageTranslations?: boolean;
+    publish?: boolean;
+    experimentalLocalizeStaticUrls?: boolean;
+    experimentalHideDefaultLocale?: boolean;
+    experimentalFlattenJsonFiles?: boolean;
+    experimentalLocalizeStaticImports?: boolean;
+    excludeStaticUrls?: string[];
+    excludeStaticImports?: string[];
+};
 export type WrapOptions = {
     src?: string[];
     config: string;
@@ -80,10 +102,11 @@ export type FilesOptions = {
 };
 export type Settings = {
     config: string;
+    configDirectory: string;
     baseUrl: string;
     dashboardUrl: string;
-    apiKey: string;
-    projectId: string;
+    apiKey?: string;
+    projectId?: string;
     defaultLocale: string;
     locales: string[];
     files: {
@@ -92,6 +115,7 @@ export type Settings = {
         transformPaths: TransformFiles;
     } | undefined;
     stageTranslations: boolean;
+    publish: boolean;
     _versionId?: string;
     version?: string;
     description?: string;

package/dist/utils/flattenJsonFiles.d.ts

@@ -1,2 +1,2 @@
-import { Settings, Options } from '../types/index.js';
-export default function flattenJsonFiles(settings: Omit<Settings & Options, 'ignoreErrors' | 'suppressWarnings' | 'timeout'>): Promise<void>;
+import { Settings } from '../types/index.js';
+export default function flattenJsonFiles(settings: Settings): Promise<void>;

package/dist/utils/hash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hashes a string using SHA-256 algorithm.
+ * @param {string} string - The string to be hashed.
+ * @returns {string} The hashed string.
+ */
+export declare function hashStringSync(string: string): string;

package/dist/utils/hash.js

@@ -0,0 +1,11 @@
+import crypto from 'crypto';
+/**
+ * Hashes a string using SHA-256 algorithm.
+ * @param {string} string - The string to be hashed.
+ * @returns {string} The hashed string.
+ */
+export function hashStringSync(string) {
+    const hash = crypto.createHash('sha256');
+    hash.update(string);
+    return hash.digest('hex');
+}

package/dist/utils/localizeStaticImports.d.ts

@@ -1,4 +1,4 @@
-import { Options, Settings } from '../types/index.js';
+import { Settings } from '../types/index.js';
 /**
  * Localizes static imports in content files.
  * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
@@ -12,4 +12,4 @@ import { Options, Settings } from '../types/index.js';
  * - Support more file types
  * - Support more complex paths
  */
-export default function localizeStaticImports(settings: Omit<Settings & Options, 'ignoreErrors' | 'suppressWarnings' | 'timeout'>): Promise<void>;
+export default function localizeStaticImports(settings: Settings): Promise<void>;

package/dist/utils/localizeStaticUrls.d.ts

@@ -1,4 +1,4 @@
-import { Options, Settings } from '../types/index.js';
+import { Settings } from '../types/index.js';
 /**
  * Localizes static urls in content files.
  * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
@@ -12,7 +12,7 @@ import { Options, Settings } from '../types/index.js';
  * - Support more file types
  * - Support more complex paths
  */
-export default function localizeStaticUrls(settings: Omit<Settings & Options, 'ignoreErrors' | 'suppressWarnings' | 'timeout'>, targetLocales?: string[]): Promise<void>;
+export default function localizeStaticUrls(settings: Settings, targetLocales?: string[]): Promise<void>;
 /**
  * Main URL transformation function that delegates to specific scenarios
  */

package/dist/utils/localizeStaticUrls.js

@@ -7,7 +7,6 @@ import remarkMdx from 'remark-mdx';
 import remarkFrontmatter from 'remark-frontmatter';
 import remarkStringify from 'remark-stringify';
 import { visit } from 'unist-util-visit';
-import { logMessage } from '../console/logging.js';
 const { isMatch } = micromatch;
 /**
  * Localizes static urls in content files.
@@ -22,8 +21,7 @@ const { isMatch } = micromatch;
  * - Support more file types
  * - Support more complex paths
  */
-export default async function localizeStaticUrls(settings, targetLocales // Optional filter for specific locales
-) {
+export default async function localizeStaticUrls(settings, targetLocales) {
     if (!settings.files ||
         (Object.keys(settings.files.placeholderPaths).length === 1 &&
             settings.files.placeholderPaths.gt)) {
@@ -54,10 +52,12 @@ export default async function localizeStaticUrls(settings, targetLocales // Opti
                 // Get file content
                 const fileContent = await fs.promises.readFile(filePath, 'utf8');
                 // Localize the file using default locale
-                const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
-                settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
-                // Write the localized file back to the same path
-                await fs.promises.writeFile(filePath, localizedFile);
+                const result = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
+                settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
+                // Only write the file if there were changes
+                if (result.hasChanges) {
+                    await fs.promises.writeFile(filePath, result.content);
+                }
             }));
             processPromises.push(defaultPromise);
         }
@@ -73,9 +73,11 @@ export default async function localizeStaticUrls(settings, targetLocales // Opti
             // Get file content
             const fileContent = await fs.promises.readFile(filePath, 'utf8');
             // Localize the file (handles both URLs and hrefs in single AST pass)
-            const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
-            // Write the localized file to the target path
-            await fs.promises.writeFile(filePath, localizedFile);
+            const result = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
+            // Only write the file if there were changes
+            if (result.hasChanges) {
+                await fs.promises.writeFile(filePath, result.content);
+            }
         }));
     });
     processPromises.push(...mappingPromises);
@@ -245,10 +247,7 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
         // Skip absolute URLs (http://, https://, //, etc.)
         if (baseDomain && shouldProcessAbsoluteUrl(originalUrl, baseDomain)) {
             // Get everything after the base domain
-            logMessage(`originalUrl: ${originalUrl}`);
-            logMessage(`baseDomain: ${baseDomain}`);
             const afterDomain = originalUrl.substring(baseDomain.length);
-            logMessage(`afterDomain: ${afterDomain}`);
             const transformedPath = transformUrlPath(afterDomain, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
             return transformedPath ? baseDomain + transformedPath : null;
         }
@@ -390,8 +389,7 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
 function localizeStaticUrlsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
 exclude = [], baseDomain) {
     // Use AST-based transformation for MDX files
-    const result = transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, baseDomain || '');
-    return result.content;
+    return transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, baseDomain || '');
 }
 function cleanPath(path) {
     let cleanedPath = path.startsWith('/') ? path.slice(1) : path;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.1.5-alpha.5",
+  "version": "2.1.5-alpha.6",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -87,7 +87,7 @@
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.4",
-    "generaltranslation": "^7.4.0",
+    "generaltranslation": "^7.4.1-alpha.2",
     "json-pointer": "^0.6.2",
     "jsonpath-plus": "^10.3.0",
     "jsonpointer": "^5.0.1",

package/dist/api/downloadFile.d.ts

@@ -1,9 +0,0 @@
-import { Settings } from '../types/index.js';
-/**
- * Downloads a file from the API and saves it to a local directory
- * @param translationId - The ID of the translation to download
- * @param outputPath - The path to save the file to
- * @param maxRetries - The maximum number of retries to attempt
- * @param retryDelay - The delay between retries in milliseconds
- */
-export declare function downloadFile(translationId: string, outputPath: string, inputPath: string, locale: string, options: Settings, maxRetries?: number, retryDelay?: number): Promise<boolean>;

package/dist/api/downloadFile.js

@@ -1,74 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { logError } from '../console/logging.js';
-import { gt } from '../utils/gt.js';
-import { validateJsonSchema } from '../formats/json/utils.js';
-import { mergeJson } from '../formats/json/mergeJson.js';
-import { TextDecoder } from 'node:util';
-import mergeYaml from '../formats/yaml/mergeYaml.js';
-import { validateYamlSchema } from '../formats/yaml/utils.js';
-/**
- * Downloads a file from the API and saves it to a local directory
- * @param translationId - The ID of the translation to download
- * @param outputPath - The path to save the file to
- * @param maxRetries - The maximum number of retries to attempt
- * @param retryDelay - The delay between retries in milliseconds
- */
-export async function downloadFile(translationId, outputPath, inputPath, locale, options, maxRetries = 3, retryDelay = 1000) {
-    let retries = 0;
-    while (retries <= maxRetries) {
-        try {
-            // Get the file data as an ArrayBuffer
-            const fileData = await gt.downloadFile(translationId);
-            // Ensure the directory exists
-            const dir = path.dirname(outputPath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            let data = new TextDecoder().decode(fileData);
-            if (options.options?.jsonSchema && locale) {
-                const jsonSchema = validateJsonSchema(options.options, inputPath);
-                if (jsonSchema) {
-                    const originalContent = fs.readFileSync(inputPath, 'utf8');
-                    if (originalContent) {
-                        data = mergeJson(originalContent, inputPath, options.options, [
-                            {
-                                translatedContent: data,
-                                targetLocale: locale,
-                            },
-                        ], options.defaultLocale)[0];
-                    }
-                }
-            }
-            if (options.options?.yamlSchema && locale) {
-                const yamlSchema = validateYamlSchema(options.options, inputPath);
-                if (yamlSchema) {
-                    const originalContent = fs.readFileSync(inputPath, 'utf8');
-                    if (originalContent) {
-                        data = mergeYaml(originalContent, inputPath, options.options, [
-                            {
-                                translatedContent: data,
-                                targetLocale: locale,
-                            },
-                        ])[0];
-                    }
-                }
-            }
-            // Write the file to disk
-            await fs.promises.writeFile(outputPath, data);
-            return true;
-        }
-        catch (error) {
-            // If we've retried too many times, log an error and return false
-            if (retries >= maxRetries) {
-                logError(`Error downloading file ${outputPath} after ${maxRetries + 1} attempts: ` +
-                    error);
-                return false;
-            }
-            // Increment retry counter and wait before next attempt
-            retries++;
-            await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        }
-    }
-    return false;
-}