gtx-cli 1.2.30-alpha.32 → 1.2.30-alpha.34

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # gtx-cli
 
+## 1.2.34
+
+### Patch Changes
+
+- [#428](https://github.com/generaltranslation/gt/pull/428) [`54036f5`](https://github.com/generaltranslation/gt/commit/54036f54308bdb9f9e6dcec93871e004dcf1be4c) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: add experimental options to translate
+
+## 1.2.33
+
+### Patch Changes
+
+- [#426](https://github.com/generaltranslation/gt/pull/426) [`ce57545`](https://github.com/generaltranslation/gt/commit/ce575454301185c663cfb93345d3058c9ceb25dd) Thanks [@brian-lou](https://github.com/brian-lou)! - Improve file pattern matching
+
+## 1.2.31
+
+### Patch Changes
+
+- [#423](https://github.com/generaltranslation/gt/pull/423) [`0ed08c7`](https://github.com/generaltranslation/gt/commit/0ed08c7bb1e63c99296b74138e4d44b718681fc8) Thanks [@brian-lou](https://github.com/brian-lou)! - Add setting configuration options
+
 ## 1.2.30
 
 ### Patch Changes

package/dist/api/checkFileTranslations.d.ts

@@ -8,7 +8,7 @@
  * @param timeoutDuration - The timeout duration for the wait in seconds
  * @returns True if all translations are deployed, false otherwise
  */
-export declare function checkFileTranslations(apiKey: string, baseUrl: string, data: {
+export declare function checkFileTranslations(projectId: string, apiKey: string, baseUrl: string, data: {
     [key: string]: {
         versionId: string;
         fileName: string;

package/dist/api/checkFileTranslations.js

@@ -3,6 +3,7 @@ import { createOraSpinner, logError } from '../console/logging.js';
 import { getLocaleProperties } from 'generaltranslation';
 import { downloadFile } from './downloadFile.js';
 import { downloadFileBatch } from './downloadFileBatch.js';
+import { getAuthHeaders } from '../utils/headers.js';
 /**
  * Checks the status of translations for a given version ID
  * @param apiKey - The API key for the General Translation API
@@ -13,7 +14,7 @@ import { downloadFileBatch } from './downloadFileBatch.js';
  * @param timeoutDuration - The timeout duration for the wait in seconds
  * @returns True if all translations are deployed, false otherwise
  */
-export async function checkFileTranslations(apiKey, baseUrl, data, locales, timeoutDuration, resolveOutputPath, downloadStatus) {
+export async function checkFileTranslations(projectId, apiKey, baseUrl, data, locales, timeoutDuration, resolveOutputPath, downloadStatus) {
     const startTime = Date.now();
     console.log();
     const spinner = await createOraSpinner();
@@ -21,7 +22,7 @@ export async function checkFileTranslations(apiKey, baseUrl, data, locales, time
     // Initialize the query data
     const fileQueryData = prepareFileQueryData(data, locales);
     // Do first check immediately
-    const initialCheck = await checkTranslationDeployment(baseUrl, apiKey, fileQueryData, downloadStatus, spinner, resolveOutputPath);
+    const initialCheck = await checkTranslationDeployment(baseUrl, projectId, apiKey, fileQueryData, downloadStatus, spinner, resolveOutputPath);
     if (initialCheck) {
         spinner.succeed(chalk.green('Files translated!'));
         return true;
@@ -33,7 +34,7 @@ export async function checkFileTranslations(apiKey, baseUrl, data, locales, time
         // Start the interval aligned with the original request time
         setTimeout(() => {
             intervalCheck = setInterval(async () => {
-                const isDeployed = await checkTranslationDeployment(baseUrl, apiKey, fileQueryData, downloadStatus, spinner, resolveOutputPath);
+                const isDeployed = await checkTranslationDeployment(baseUrl, projectId, apiKey, fileQueryData, downloadStatus, spinner, resolveOutputPath);
                 const elapsed = Date.now() - startTime;
                 if (isDeployed || elapsed >= timeoutDuration * 1000) {
                     clearInterval(intervalCheck);
@@ -156,7 +157,7 @@ function generateStatusSuffixText(downloadStatus, fileQueryData) {
 /**
  * Checks translation status and downloads ready files
  */
-async function checkTranslationDeployment(baseUrl, apiKey, fileQueryData, downloadStatus, spinner, resolveOutputPath) {
+async function checkTranslationDeployment(baseUrl, projectId, apiKey, fileQueryData, downloadStatus, spinner, resolveOutputPath) {
     try {
         // Only query for files that haven't been downloaded yet
         const currentQueryData = fileQueryData.filter((item) => !downloadStatus.downloaded.has(`${item.fileName}:${item.locale}`) &&
@@ -169,7 +170,7 @@ async function checkTranslationDeployment(baseUrl, apiKey, fileQueryData, downlo
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                ...(apiKey && { 'x-gt-api-key': apiKey }),
+                ...getAuthHeaders(projectId, apiKey),
             },
             body: JSON.stringify({ files: currentQueryData }),
         });
@@ -193,7 +194,7 @@ async function checkTranslationDeployment(baseUrl, apiKey, fileQueryData, downlo
                 });
                 // Use batch download if there are multiple files
                 if (batchFiles.length > 1) {
-                    const batchResult = await downloadFileBatch(baseUrl, apiKey, batchFiles.map(({ translationId, outputPath }) => ({
+                    const batchResult = await downloadFileBatch(baseUrl, projectId, apiKey, batchFiles.map(({ translationId, outputPath }) => ({
                         translationId,
                         outputPath,
                     })));
@@ -211,7 +212,7 @@ async function checkTranslationDeployment(baseUrl, apiKey, fileQueryData, downlo
                 else if (batchFiles.length === 1) {
                     // For a single file, use the original downloadFile method
                     const file = batchFiles[0];
-                    const result = await downloadFile(baseUrl, apiKey, file.translationId, file.outputPath);
+                    const result = await downloadFile(baseUrl, projectId, apiKey, file.translationId, file.outputPath);
                     if (result) {
                         downloadStatus.downloaded.add(file.fileLocale);
                     }

package/dist/api/downloadFile.d.ts

@@ -1 +1 @@
-export declare function downloadFile(baseUrl: string, apiKey: string, translationId: string, outputPath: string, maxRetries?: number, retryDelay?: number): Promise<boolean>;
+export declare function downloadFile(baseUrl: string, projectId: string, apiKey: string, translationId: string, outputPath: string, maxRetries?: number, retryDelay?: number): Promise<boolean>;

package/dist/api/downloadFile.js

@@ -1,15 +1,16 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { logError } from '../console/logging.js';
+import { getAuthHeaders } from '../utils/headers.js';
 // Helper function to download a file
-export async function downloadFile(baseUrl, apiKey, translationId, outputPath, maxRetries = 3, retryDelay = 1000) {
+export async function downloadFile(baseUrl, projectId, apiKey, translationId, outputPath, maxRetries = 3, retryDelay = 1000) {
     let retries = 0;
     while (retries <= maxRetries) {
         try {
             const downloadResponse = await fetch(`${baseUrl}/v1/project/translations/files/${translationId}/download`, {
                 method: 'GET',
                 headers: {
-                    ...(apiKey && { 'x-gt-api-key': apiKey }),
+                    ...getAuthHeaders(projectId, apiKey),
                 },
             });
             if (downloadResponse.ok) {

package/dist/api/downloadFileBatch.d.ts

@@ -7,7 +7,7 @@
  * @param retryDelay - Delay between retries in milliseconds
  * @returns Object containing successful and failed file IDs
  */
-export declare function downloadFileBatch(baseUrl: string, apiKey: string, files: Array<{
+export declare function downloadFileBatch(baseUrl: string, projectId: string, apiKey: string, files: Array<{
     translationId: string;
     outputPath: string;
 }>, maxRetries?: number, retryDelay?: number): Promise<{

package/dist/api/downloadFileBatch.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { logError, logWarning } from '../console/logging.js';
+import { getAuthHeaders } from '../utils/headers.js';
 /**
  * Downloads multiple translation files in a single batch request
  * @param baseUrl - The base URL for the General Translation API
@@ -10,7 +11,7 @@ import { logError, logWarning } from '../console/logging.js';
  * @param retryDelay - Delay between retries in milliseconds
  * @returns Object containing successful and failed file IDs
  */
-export async function downloadFileBatch(baseUrl, apiKey, files, maxRetries = 3, retryDelay = 1000) {
+export async function downloadFileBatch(baseUrl, projectId, apiKey, files, maxRetries = 3, retryDelay = 1000) {
     let retries = 0;
     const fileIds = files.map((file) => file.translationId);
     const result = { successful: [], failed: [] };
@@ -22,7 +23,7 @@ export async function downloadFileBatch(baseUrl, apiKey, files, maxRetries = 3,
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
-                    ...(apiKey && { 'x-gt-api-key': apiKey }),
+                    ...getAuthHeaders(projectId, apiKey),
                 },
                 body: JSON.stringify({ fileIds }),
             });

package/dist/api/fetchTranslations.d.ts

@@ -7,4 +7,4 @@ import { RetrievedTranslations } from '../types/api.js';
  * @param translationsDir - The directory to save the translations to
  * @param fileType - The file type to save the translations as (file extension)
  */
-export declare function fetchTranslations(baseUrl: string, apiKey: string, versionId: string): Promise<RetrievedTranslations>;
+export declare function fetchTranslations(baseUrl: string, projectId: string, apiKey: string, versionId: string): Promise<RetrievedTranslations>;

package/dist/api/fetchTranslations.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { logError } from '../console/logging.js';
+import { getAuthHeaders } from '../utils/headers.js';
 /**
  * Fetches translations from the API and saves them to a local directory
  * @param baseUrl - The base URL for the API
@@ -8,13 +9,13 @@ import { logError } from '../console/logging.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 fetchTranslations(baseUrl, apiKey, versionId) {
+export async function fetchTranslations(baseUrl, projectId, apiKey, versionId) {
     // First fetch the translations from the API
     const response = await fetch(`${baseUrl}/v1/project/translations/info/${encodeURIComponent(versionId)}`, {
         method: 'GET',
         headers: {
             'Content-Type': 'application/json',
-            ...(apiKey && { 'x-gt-api-key': apiKey }),
+            ...getAuthHeaders(projectId, apiKey),
         },
     });
     if (response.ok) {

package/dist/api/sendFiles.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { createSpinner, logMessage, logSuccess } from '../console/logging.js';
+import { getAuthHeaders } from '../utils/headers.js';
 /**
  * Sends multiple files for translation to the API
  * @param files - Array of file objects to translate
@@ -7,7 +8,6 @@ import { createSpinner, logMessage, logSuccess } from '../console/logging.js';
  * @returns The translated content or version ID
  */
 export async function sendFiles(files, options) {
-    const { apiKey } = options;
     logMessage(chalk.cyan('Files to translate:') +
         '\n' +
         files.map((file) => `  - ${chalk.bold(file.fileName)}`).join('\n'));
@@ -35,7 +35,7 @@ export async function sendFiles(files, options) {
         const response = await fetch(`${options.baseUrl}/v1/project/translations/files/upload`, {
             method: 'POST',
             headers: {
-                ...(apiKey && { 'x-gt-api-key': apiKey }),
+                ...getAuthHeaders(options.projectId, options.apiKey),
             },
             body: formData,
         });

package/dist/api/sendUpdates.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { createSpinner, logSuccess, logWarning } from '../console/logging.js';
 import updateConfig from '../fs/config/updateConfig.js';
 import { isUsingLocalTranslations } from '../config/utils.js';
+import { getAuthHeaders } from '../utils/headers.js';
 /**
  * Sends updates to the API
  * @param updates - The updates to send
@@ -35,7 +36,7 @@ export async function sendUpdates(updates, options, library) {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                ...(apiKey && { 'x-gt-api-key': apiKey }),
+                ...getAuthHeaders(options.projectId, options.apiKey),
             },
             body: JSON.stringify(body),
         });

package/dist/api/waitForUpdates.d.ts

@@ -8,4 +8,4 @@
  * @param timeoutDuration - The timeout duration for the wait
  * @returns True if all translations are deployed, false otherwise
  */
-export declare const waitForUpdates: (apiKey: string, baseUrl: string, versionId: string, startTime: number, timeoutDuration: number) => Promise<boolean>;
+export declare const waitForUpdates: (projectId: string, apiKey: string, baseUrl: string, versionId: string, startTime: number, timeoutDuration: number) => Promise<boolean>;

package/dist/api/waitForUpdates.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { createOraSpinner, logErrorAndExit, } from '../console/logging.js';
 import { getLocaleProperties } from 'generaltranslation';
+import { getAuthHeaders } from '../utils/headers.js';
 /**
  * Waits for translations to be deployed to the General Translation API
  * @param apiKey - The API key for the General Translation API
@@ -11,7 +12,7 @@ import { getLocaleProperties } from 'generaltranslation';
  * @param timeoutDuration - The timeout duration for the wait
  * @returns True if all translations are deployed, false otherwise
  */
-export const waitForUpdates = async (apiKey, baseUrl, versionId, startTime, timeoutDuration) => {
+export const waitForUpdates = async (projectId, apiKey, baseUrl, versionId, startTime, timeoutDuration) => {
     console.log();
     const spinner = await createOraSpinner();
     spinner.start('Waiting for translation...');
@@ -21,7 +22,7 @@ export const waitForUpdates = async (apiKey, baseUrl, versionId, startTime, time
                 method: 'GET',
                 headers: {
                     'Content-Type': 'application/json',
-                    ...(apiKey && { 'x-gt-api-key': apiKey }),
+                    ...getAuthHeaders(projectId, apiKey),
                 },
             });
             if (response.ok) {

package/dist/cli/react.js

@@ -16,6 +16,8 @@ import updateConfig from '../fs/config/updateConfig.js';
 import { validateConfigExists } from '../config/validateSettings.js';
 import { validateProject } from '../translation/validate.js';
 import { intro } from '@clack/prompts';
+import localizeStaticUrls from '../utils/localizeStaticUrls.js';
+import flattenJsonFiles from '../utils/flattenJsonFiles.js';
 const DEFAULT_TIMEOUT = 600;
 const pkg = 'gt-react';
 export class ReactCLI extends BaseCLI {
@@ -75,6 +77,9 @@ export class ReactCLI extends BaseCLI {
             .option('--ignore-errors', 'Ignore errors encountered while scanning for <T> tags', false)
             .option('--dry-run', 'Dry run, does not send updates to General Translation API', false)
             .option('--timeout <seconds>', 'Timeout in seconds for waiting for updates to be deployed to the CDN', DEFAULT_TIMEOUT.toString())
+            .option('--experimental-localize-static-urls', 'Triggering this will run a script after the cli tool that localizes all urls in content files. Currently only supported for md and mdx files.', false)
+            .option('--experimental-hide-default-locale', 'When localizing static locales, hide the default locale from the path', false)
+            .option('--experimental-flatten-json-files', 'Triggering this will flatten the json files into a single file. This is useful for projects that have a lot of json files.', false)
             .action(async (options) => {
             displayHeader('Translating project...');
             await this.handleTranslate(options);
@@ -262,7 +267,7 @@ export class ReactCLI extends BaseCLI {
             await super.handleGenericTranslate(options);
             // If the base class's handleTranslate completes successfully, continue with ReactCLI-specific code
         }
-        catch (error) {
+        catch {
             // Continue with ReactCLI-specific code even if base handleTranslate failed
         }
         if (!settings.stageTranslations) {
@@ -280,6 +285,14 @@ export class ReactCLI extends BaseCLI {
             }
             await translate(options, settings._versionId);
         }
+        // Localize static urls (/docs -> /[locale]/docs)
+        if (options.experimentalLocalizeStaticUrls) {
+            await localizeStaticUrls(options);
+        }
+        // Flatten json files into a single file
+        if (options.experimentalFlattenJsonFiles) {
+            await flattenJsonFiles(options);
+        }
     }
     async handleValidate(initOptions) {
         validateConfigExists();

package/dist/config/generateSettings.js

@@ -1,5 +1,5 @@
-import { displayProjectId, warnApiKeyInConfig } from '../console/logging.js';
-import loadConfig from '../fs/config/loadConfig.js';
+import { displayProjectId, logErrorAndExit, warnApiKeyInConfig, } from '../console/logging.js';
+import { loadConfig } from '../fs/config/loadConfig.js';
 import { defaultBaseUrl, libraryDefaultLocale, } from 'generaltranslation/internal';
 import fs from 'node:fs';
 import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
@@ -8,6 +8,8 @@ import { validateSettings } from './validateSettings.js';
 import { GT_DASHBOARD_URL } from '../utils/constants.js';
 import { resolveProjectId } from '../fs/utils.js';
 import path from 'node:path';
+import chalk from 'chalk';
+import { resolveConfig } from './resolveConfig.js';
 export const DEFAULT_SRC_PATTERNS = [
     'src/**/*.{js,jsx,ts,tsx}',
     'app/**/*.{js,jsx,ts,tsx}',
@@ -29,23 +31,33 @@ export async function generateSettings(options, cwd = process.cwd()) {
     if (options.config) {
         gtConfig = loadConfig(options.config);
     }
-    else if (fs.existsSync(path.join(cwd, 'gt.config.json'))) {
-        options.config = path.join(cwd, 'gt.config.json');
-        gtConfig = loadConfig(options.config);
-    }
-    else if (fs.existsSync(path.join(cwd, 'src/gt.config.json'))) {
-        options.config = path.join(cwd, 'src/gt.config.json');
-        gtConfig = loadConfig(options.config);
-    }
     else {
-        // If neither config exists, use empty config
-        gtConfig = {};
+        const config = resolveConfig(cwd);
+        if (config) {
+            gtConfig = config.config;
+            options.config = config.path;
+        }
+        else {
+            gtConfig = {};
+        }
     }
     // Warn if apiKey is present in gt.config.json
     if (gtConfig.apiKey) {
         warnApiKeyInConfig(options.config);
         process.exit(1);
     }
+    const projectIdEnv = resolveProjectId();
+    // Resolve mismatched projectIds
+    if (gtConfig.projectId &&
+        options.projectId &&
+        gtConfig.projectId !== options.projectId) {
+        logErrorAndExit(`Project ID mismatch between ${chalk.green(gtConfig.projectId)} and ${chalk.green(options.projectId)}! Please use the same projectId in all configs.`);
+    }
+    else if (gtConfig.projectId &&
+        projectIdEnv &&
+        gtConfig.projectId !== projectIdEnv) {
+        logErrorAndExit(`Project ID mismatch between ${chalk.green(gtConfig.projectId)} and ${chalk.green(projectIdEnv)}! Please use the same projectId in all configs.`);
+    }
     // merge options
     const mergedOptions = { ...gtConfig, ...options };
     // merge locales

package/dist/config/resolveConfig.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveConfig(cwd: string): {
+    path: string;
+    config: Record<string, any>;
+} | null;

package/dist/config/resolveConfig.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from '../fs/config/loadConfig.js';
+export function resolveConfig(cwd) {
+    const configFilepath = 'gt.config.json';
+    if (fs.existsSync(path.join(cwd, configFilepath))) {
+        return {
+            path: path.join(cwd, configFilepath),
+            config: loadConfig(path.join(cwd, configFilepath)),
+        };
+    }
+    if (fs.existsSync(path.join(cwd, 'src/gt.config.json'))) {
+        return {
+            path: path.join(cwd, 'src/gt.config.json'),
+            config: loadConfig(path.join(cwd, 'src/gt.config.json')),
+        };
+    }
+    return null;
+}

package/dist/formats/files/translate.d.ts

@@ -11,3 +11,7 @@ import { TranslateOptions } from '../../cli/base.js';
  * @returns Promise that resolves when translation is complete
  */
 export declare function translateFiles(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, dataFormat: DataFormat | undefined, options: Settings & TranslateOptions): Promise<void>;
+/**
+ * Creates a mapping between source files and their translated counterparts for each locale
+ */
+export declare function createFileMapping(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, locales: string[]): Record<string, Record<string, string>>;

package/dist/formats/files/translate.js

@@ -10,6 +10,7 @@ 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';
 const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
 /**
  * Sends multiple files to the API for translation
@@ -49,9 +50,10 @@ export async function translateFiles(filePaths, placeholderPaths, transformPaths
         if (filePaths[fileType]) {
             const files = filePaths[fileType].map((filePath) => {
                 const content = readFile(filePath);
+                const sanitizedContent = sanitizeFileContent(content);
                 const relativePath = getRelative(filePath);
                 return {
-                    content,
+                    content: sanitizedContent,
                     fileName: relativePath,
                     fileExtension: fileType.toUpperCase(),
                     dataFormat,
@@ -98,7 +100,7 @@ export async function translateFiles(filePaths, placeholderPaths, transformPaths
         // Process any translations that were already completed and returned with the initial response
         const downloadStatus = await processInitialTranslations(translations, fileMapping, options);
         // Check for remaining translations
-        await checkFileTranslations(options.apiKey, options.baseUrl, data, locales, 600, (sourcePath, locale) => fileMapping[locale][sourcePath], downloadStatus // Pass the already downloaded files to avoid duplicate requests
+        await checkFileTranslations(options.projectId, options.apiKey, options.baseUrl, data, locales, 600, (sourcePath, locale) => fileMapping[locale][sourcePath], downloadStatus // Pass the already downloaded files to avoid duplicate requests
         );
     }
     catch (error) {
@@ -108,7 +110,7 @@ export async function translateFiles(filePaths, placeholderPaths, transformPaths
 /**
  * Creates a mapping between source files and their translated counterparts for each locale
  */
-function createFileMapping(filePaths, placeholderPaths, transformPaths, locales) {
+export function createFileMapping(filePaths, placeholderPaths, transformPaths, locales) {
     const fileMapping = {};
     for (const locale of locales) {
         const translatedPaths = resolveLocaleFiles(placeholderPaths, locale);
@@ -180,7 +182,7 @@ async function processInitialTranslations(translations = [], fileMapping, option
         }
         // Use batch download if there are multiple files
         if (batchFiles.length > 1) {
-            const batchResult = await downloadFileBatch(options.baseUrl, options.apiKey, batchFiles.map(({ translationId, outputPath }) => ({
+            const batchResult = await downloadFileBatch(options.baseUrl, options.projectId, options.apiKey, batchFiles.map(({ translationId, outputPath }) => ({
                 translationId,
                 outputPath,
             })));
@@ -198,7 +200,7 @@ async function processInitialTranslations(translations = [], fileMapping, option
         else if (batchFiles.length === 1) {
             // For a single file, use the original downloadFile method
             const file = batchFiles[0];
-            const result = await downloadFile(options.baseUrl, options.apiKey, file.translationId, file.outputPath);
+            const result = await downloadFile(options.baseUrl, options.projectId, options.apiKey, file.translationId, file.outputPath);
             if (result) {
                 downloadStatus.downloaded.add(file.fileLocale);
             }

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

@@ -1 +1 @@
-export default function loadConfig(filepath: string): Record<string, any>;
+export declare function loadConfig(filepath: string): Record<string, any>;

package/dist/fs/config/loadConfig.js

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-export default function loadConfig(filepath) {
+export function loadConfig(filepath) {
     try {
         return JSON.parse(fs.readFileSync(filepath, 'utf-8'));
     }

package/dist/fs/config/parseFilesConfig.js

@@ -92,29 +92,30 @@ function expandGlobPatterns(cwd, includePatterns, excludePatterns, locale, trans
         resolvedPaths.push(...matches);
         // For each match, create a version with [locale] in the correct positions
         matches.forEach((match) => {
-            // Convert to relative path to make replacement easier
-            const relativePath = path.relative(cwd, match);
-            let originalRelativePath = relativePath;
-            // Replace locale with [locale] at each tracked position
+            // Convert to absolute path to make replacement easier
+            const absolutePath = path.resolve(cwd, match);
+            const patternPath = path.resolve(cwd, pattern);
+            let originalAbsolutePath = absolutePath;
             if (localePositions.length > 0) {
-                // We need to account for path resolution differences
-                // This is a simplified approach - we'll replace all instances of the locale
+                // Replace all instances of [locale]
                 // but only in path segments where we expect it based on the original pattern
-                const pathParts = relativePath.split(path.sep);
-                const patternParts = pattern.split(/[\/\\]/); // Handle both slash types
+                const pathParts = absolutePath.split(path.sep);
+                const patternParts = patternPath.split(path.sep);
                 for (let i = 0; i < pathParts.length; i++) {
                     if (i < patternParts.length) {
                         if (patternParts[i].includes(localeTag)) {
                             // This segment should have the locale replaced
-                            pathParts[i] = pathParts[i].replace(locale, localeTag);
+                            // Create regex from pattern to match the actual path structure
+                            const regexPattern = patternParts[i].replace(/\[locale\]/g, `(${locale.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`);
+                            const regex = new RegExp(regexPattern);
+                            pathParts[i] = pathParts[i].replace(regex, patternParts[i].replace(/\[locale\]/g, localeTag));
                         }
                     }
                 }
-                originalRelativePath = pathParts.join(path.sep);
+                originalAbsolutePath = pathParts.join(path.sep);
             }
             // Convert back to absolute path
-            const originalPath = path.resolve(cwd, originalRelativePath);
-            placeholderPaths.push(originalPath);
+            placeholderPaths.push(originalAbsolutePath);
         });
     }
     return { resolvedPaths, placeholderPaths };

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

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

package/dist/fs/config/setupConfig.js

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

package/dist/translation/translate.js

@@ -6,11 +6,11 @@ export async function translate(settings, versionId) {
     // timeout was validated earlier
     const startTime = Date.now();
     const timeout = parseInt(settings.timeout) * 1000;
-    const result = await waitForUpdates(settings.apiKey, settings.baseUrl, versionId, startTime, timeout);
+    const result = await waitForUpdates(settings.projectId, settings.apiKey, settings.baseUrl, versionId, startTime, timeout);
     if (!result) {
         process.exit(1);
     }
-    const translations = await fetchTranslations(settings.baseUrl, settings.apiKey, versionId);
+    const translations = await fetchTranslations(settings.baseUrl, settings.projectId, settings.apiKey, versionId);
     // Save translations to local directory if files.gt.output is provided
     if (settings.files && isUsingLocalTranslations(settings)) {
         await saveTranslations(translations, settings.files.placeholderPaths, 'JSX');

package/dist/types/index.d.ts

@@ -28,6 +28,9 @@ export type Options = {
     dryRun: boolean;
     timeout: string;
     stageTranslations?: boolean;
+    experimentalLocalizeStaticUrls?: boolean;
+    experimentalHideDefaultLocale?: boolean;
+    experimentalFlattenJsonFiles?: boolean;
 };
 export type WrapOptions = {
     src?: string[];

package/dist/utils/flattenJsonFiles.d.ts

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

package/dist/utils/flattenJsonFiles.js

@@ -0,0 +1,36 @@
+import { createFileMapping } from '../formats/files/translate.js';
+import fs from 'node:fs';
+export default async function flattenJsonFiles(settings) {
+    if (!settings.files ||
+        (Object.keys(settings.files.placeholderPaths).length === 1 &&
+            settings.files.placeholderPaths.gt)) {
+        return;
+    }
+    const { resolvedPaths: sourceFiles } = settings.files;
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales);
+    await Promise.all(Object.values(fileMapping).map(async (filesMap) => {
+        const targetFiles = Object.values(filesMap).filter((path) => path.endsWith('.json'));
+        await Promise.all(targetFiles.map(async (file) => {
+            // Read each json file
+            const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+            // Flatten the json
+            const flattenedJson = flattenJson(json);
+            // Write the flattened json to the target file
+            await fs.promises.writeFile(file, JSON.stringify(flattenedJson, null, 2));
+            return flattenedJson;
+        }));
+    }));
+}
+function flattenJson(json, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(json)) {
+        const newKey = prefix ? `${prefix}.${key}` : key;
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            Object.assign(result, flattenJson(value, newKey));
+        }
+        else {
+            result[newKey] = value;
+        }
+    }
+    return result;
+}

package/dist/utils/headers.d.ts

@@ -0,0 +1 @@
+export declare function getAuthHeaders(projectId: string, apiKey: string): Record<string, string>;

package/dist/utils/headers.js

@@ -0,0 +1,14 @@
+export function getAuthHeaders(projectId, apiKey) {
+    const authHeaders = {
+        'x-gt-project-id': projectId,
+    };
+    if (apiKey) {
+        if (apiKey.startsWith('gtx-internal-')) {
+            authHeaders['x-gt-internal-api-key'] = apiKey;
+        }
+        else {
+            authHeaders['x-gt-api-key'] = apiKey;
+        }
+    }
+    return authHeaders;
+}

package/dist/utils/localizeStaticUrls.d.ts

@@ -0,0 +1,15 @@
+import { Options, Settings } from '../types/index.js';
+/**
+ * Localizes static urls in content files.
+ * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
+ * @param settings - The settings object containing the project configuration.
+ * @returns void
+ *
+ * @TODO This is an experimental feature, and only works in very specific cases. This needs to be improved before
+ * it can be enabled by default.
+ *
+ * Before this becomes a non-experimental feature, we need to:
+ * - Support more file types
+ * - Support more complex paths
+ */
+export default function localizeStaticUrls(settings: Settings & Options): Promise<void>;

package/dist/utils/localizeStaticUrls.js

@@ -0,0 +1,78 @@
+import * as fs from 'fs';
+import { createFileMapping } from '../formats/files/translate.js';
+/**
+ * Localizes static urls in content files.
+ * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
+ * @param settings - The settings object containing the project configuration.
+ * @returns void
+ *
+ * @TODO This is an experimental feature, and only works in very specific cases. This needs to be improved before
+ * it can be enabled by default.
+ *
+ * Before this becomes a non-experimental feature, we need to:
+ * - Support more file types
+ * - Support more complex paths
+ */
+export default async function localizeStaticUrls(settings) {
+    if (!settings.files ||
+        (Object.keys(settings.files.placeholderPaths).length === 1 &&
+            settings.files.placeholderPaths.gt)) {
+        return;
+    }
+    const { resolvedPaths: sourceFiles } = settings.files;
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales);
+    // Process all file types at once with a single call
+    await Promise.all(Object.entries(fileMapping).map(async ([locale, filesMap]) => {
+        // Get all files that are md or mdx
+        const targetFiles = Object.values(filesMap).filter((path) => path.endsWith('.md') || path.endsWith('.mdx'));
+        // Replace the placeholder path with the target path
+        await Promise.all(targetFiles.map(async (filePath) => {
+            // Get file content
+            const fileContent = fs.readFileSync(filePath, 'utf8');
+            // Localize the file
+            const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.experimentalHideDefaultLocale || false);
+            // Write the localized file to the target path
+            await fs.promises.writeFile(filePath, localizedFile);
+        }));
+    }));
+}
+// Assumption: we will be seeing localized paths in the source files: (docs/en/ -> docs/ja/)
+function localizeStaticUrlsForFile(file, defaultLocale, targetLocale, hideDefaultLocale) {
+    // 1. Search for all instances of:
+    let regex;
+    if (hideDefaultLocale) {
+        // Match complete markdown links: `](/docs/...)` or `](/docs)`
+        regex = new RegExp(`\\]\\(/docs(?:/([^)]*))?\\)`, 'g');
+    }
+    else {
+        // Match complete markdown links with default locale: `](/docs/${defaultLocale}/...)` or `](/docs/${defaultLocale})`
+        regex = new RegExp(`\\]\\(/docs/${defaultLocale}(?:/([^)]*))?\\)`, 'g');
+    }
+    const matches = file.match(regex);
+    if (!matches) {
+        return file;
+    }
+    // 2. Replace the default locale with the target locale in all matched instances
+    const localizedFile = file.replace(regex, (match, pathContent) => {
+        if (hideDefaultLocale) {
+            // For hideDefaultLocale, check if path already has target locale
+            if (pathContent) {
+                if (pathContent.startsWith(`${targetLocale}/`) ||
+                    pathContent === targetLocale) {
+                    return match; // Already localized
+                }
+            }
+            // Add target locale to the path
+            if (!pathContent || pathContent === '') {
+                return `](/docs/${targetLocale})`;
+            }
+            return `](/docs/${targetLocale}/${pathContent})`;
+        }
+        else {
+            // For non-hideDefaultLocale, replace defaultLocale with targetLocale
+            // pathContent contains everything after the default locale (no leading slash if present)
+            return `](/docs/${targetLocale}${pathContent ? '/' + pathContent : ''})`;
+        }
+    });
+    return localizedFile;
+}

package/dist/utils/sanitizeFileContent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Processes content to escape curl commands within tick marks and existing escape strings
+ * @param content - The content to process
+ * @returns the processed content with escaped curl commands
+ */
+export default function sanitizeFileContent(content: string): string;

package/dist/utils/sanitizeFileContent.js

@@ -0,0 +1,29 @@
+/**
+ * Processes content to escape curl commands within tick marks and existing escape strings
+ * @param content - The content to process
+ * @returns the processed content with escaped curl commands
+ */
+export default function sanitizeFileContent(content) {
+    const ESCAPE_STRING = '_GT_INTERNAL_ESCAPE';
+    const allTickMarkRegex = /`([^`]*)`/g;
+    let processedContent = content;
+    // First, escape any existing tick marks followed by _GT_INTERNAL_ESCAPE
+    // This protects pre-existing escapes
+    processedContent = processedContent.replace(new RegExp('`' + ESCAPE_STRING, 'g'), '`' + ESCAPE_STRING + ESCAPE_STRING);
+    // Then find ALL tick mark pairs and process them individually
+    // This approach is more reliable than negative lookahead with modified content
+    processedContent = processedContent.replace(allTickMarkRegex, (match, innerContent) => {
+        // Skip if this already starts with our escape string (protected or already processed)
+        if (innerContent.startsWith(ESCAPE_STRING)) {
+            return match;
+        }
+        // Check if the content contains a curl command
+        if (/\bcurl\b/i.test(innerContent)) {
+            // Insert escape string after opening tick
+            return '`' + ESCAPE_STRING + innerContent + '`';
+        }
+        // Return original match if no curl command found
+        return match;
+    });
+    return processedContent;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "1.2.30-alpha.32",
+  "version": "1.2.30-alpha.34",
   "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.2",
-    "generaltranslation": "^7.0.0-alpha.32",
+    "generaltranslation": "^7.0.0-alpha.34",
     "open": "^10.1.1",
     "ora": "^8.2.0",
     "resolve": "^1.22.10",