gtx-cli 1.2.31 → 1.2.34

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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

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/formats/files/translate.d.ts

@@ -12,3 +12,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
@@ -50,9 +51,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,
                     fileFormat: fileType.toUpperCase(),
                     dataFormat,
@@ -109,7 +111,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);

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/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/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.31",
+  "version": "1.2.34",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [