gtx-cli 2.3.6 → 2.3.8

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.3.8
+
+### Patch Changes
+
+- [#713](https://github.com/generaltranslation/gt/pull/713) [`b8feb26`](https://github.com/generaltranslation/gt/commit/b8feb2638613f54b76b5f3768edc6039db512c53) Thanks [@SamEggert](https://github.com/SamEggert)! - rename clearLocaleFolders to clearLocaleDirs
+
+## 2.3.7
+
+### Patch Changes
+
+- [#710](https://github.com/generaltranslation/gt/pull/710) [`8325bae`](https://github.com/generaltranslation/gt/commit/8325bae9a8661a0b269131ac6dadefab327c5b2c) Thanks [@SamEggert](https://github.com/SamEggert)! - add clearLocaleFolders option
+
 ## 2.3.6
 
 ### Patch Changes

package/dist/api/checkFileTranslations.js

@@ -4,6 +4,8 @@ import { getLocaleProperties } from 'generaltranslation';
 import { downloadFileBatch } from './downloadFileBatch.js';
 import { gt } from '../utils/gt.js';
 import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
+import { clearLocaleDirs } from '../fs/clearLocaleDirs.js';
+import path from 'node:path';
 /**
  * Checks the status of translations for a given version ID
  * @param apiKey - The API key for the General Translation API
@@ -24,6 +26,22 @@ export async function checkFileTranslations(data, locales, timeoutDuration, reso
     spinner.start(spinnerMessage);
     // Initialize the query data
     const fileQueryData = prepareFileQueryData(data, locales);
+    // Clear translated files before any downloads (if enabled)
+    if (options.options?.experimentalClearLocaleDirs === true &&
+        fileQueryData.length > 0) {
+        const translatedFiles = new Set(fileQueryData
+            .map((file) => {
+            const outputPath = resolveOutputPath(file.fileName, file.locale);
+            // Only clear if the output path is different from the source (i.e., there's a transform)
+            return outputPath !== null && outputPath !== file.fileName
+                ? outputPath
+                : null;
+        })
+            .filter((path) => path !== null));
+        // Derive cwd from config path
+        const cwd = path.dirname(options.config);
+        await clearLocaleDirs(translatedFiles, locales, options.options?.clearLocaleDirsExclude, cwd);
+    }
     const downloadStatus = {
         downloaded: new Set(),
         failed: new Set(),

package/dist/cli/flags.js

@@ -24,7 +24,8 @@ export function attachTranslateFlags(command) {
         .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)
         .option('--experimental-localize-static-imports', 'Triggering this will run a script after the cli tool that localizes all static imports in content files. Currently only supported for md and mdx files.', false)
-        .option('--force', 'Force a retranslation, invalidating all existing cached translations if they exist.', false);
+        .option('--force', 'Force a retranslation, invalidating all existing cached translations if they exist.', false)
+        .option('--experimental-clear-locale-dirs', 'Clear locale directories before downloading new translations', false);
     return command;
 }
 export function attachAdditionalReactTranslateFlags(command) {

package/dist/config/generateSettings.js

@@ -126,6 +126,10 @@ export async function generateSettings(options, cwd = process.cwd()) {
             options.experimentalHideDefaultLocale,
         experimentalFlattenJsonFiles: gtConfig.options?.experimentalFlattenJsonFiles ||
             options.experimentalFlattenJsonFiles,
+        experimentalClearLocaleDirs: gtConfig.options?.experimentalClearLocaleDirs ||
+            options.experimentalClearLocaleDirs,
+        clearLocaleDirsExclude: gtConfig.options?.clearLocaleDirsExclude ||
+            options.clearLocaleDirsExclude,
     };
     // Add additional options if provided
     if (mergedOptions.options) {

package/dist/fs/clearLocaleDirs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Clears translated files before writing new translations
+ * @param filePaths - Set of translated file paths to clear
+ * @param locales - Array of locale codes to match against
+ * @param excludePatterns - Optional array of glob patterns to exclude from clearing (supports [locale] and [locales])
+ * @param cwd - Current working directory for resolving relative exclude patterns (defaults to process.cwd())
+ */
+export declare function clearLocaleDirs(filePaths: Set<string>, locales: string[], excludePatterns?: string[], cwd?: string): Promise<void>;

package/dist/fs/clearLocaleDirs.js

@@ -0,0 +1,126 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+import { logSuccess, logWarning } from '../console/logging.js';
+import fg from 'fast-glob';
+import micromatch from 'micromatch';
+/**
+ * Extracts locale directories from translated file paths.
+ * Groups files by their immediate parent containing a locale code.
+ * For example: "snippets/es/api-test/file.mdx" -> "snippets/es"
+ */
+function extractLocaleDirectories(filePaths, locales) {
+    const localeDirs = new Set();
+    const localeSet = new Set(locales);
+    for (const filePath of filePaths) {
+        const parts = filePath.split(path.sep);
+        // Find directory segments that match the provided locales
+        for (let i = 0; i < parts.length - 1; i++) {
+            const segment = parts[i];
+            if (localeSet.has(segment)) {
+                // Found a locale directory, capture up to and including this segment
+                const localeDir = parts.slice(0, i + 1).join(path.sep);
+                localeDirs.add(localeDir);
+                break;
+            }
+        }
+    }
+    return localeDirs;
+}
+async function getAllFiles(dirPath) {
+    return await fg(path.join(dirPath, '**/*'), {
+        absolute: true,
+        onlyFiles: true,
+    });
+}
+async function getFilesToDelete(dirPath, excludePatterns, currentLocale, cwd) {
+    const allFiles = await getAllFiles(dirPath);
+    const absoluteCwd = path.resolve(cwd);
+    const expandedExcludePatterns = excludePatterns.map((p) => {
+        const resolvedPattern = path.isAbsolute(p) ? p : path.join(absoluteCwd, p);
+        return resolvedPattern
+            .replace(/\[locale\]/g, currentLocale)
+            .replace(/\[locales\]/g, currentLocale);
+    });
+    const filesToKeep = micromatch(allFiles, expandedExcludePatterns, {
+        dot: true,
+    });
+    const filesToKeepSet = new Set(filesToKeep);
+    return allFiles.filter((file) => !filesToKeepSet.has(file));
+}
+/**
+ * Clears translated files before writing new translations
+ * @param filePaths - Set of translated file paths to clear
+ * @param locales - Array of locale codes to match against
+ * @param excludePatterns - Optional array of glob patterns to exclude from clearing (supports [locale] and [locales])
+ * @param cwd - Current working directory for resolving relative exclude patterns (defaults to process.cwd())
+ */
+export async function clearLocaleDirs(filePaths, locales, excludePatterns, cwd = process.cwd()) {
+    // Extract locale directories
+    const localeDirs = extractLocaleDirectories(filePaths, locales);
+    for (const dir of localeDirs) {
+        try {
+            await fs.stat(dir);
+            // Extract locale from directory path
+            const dirParts = dir.split(path.sep);
+            const locale = locales.find((loc) => dirParts.includes(loc));
+            if (!locale) {
+                continue;
+            }
+            if (!excludePatterns?.length) {
+                await fs.rm(dir, { recursive: true, force: true });
+                logSuccess(`Cleared locale directory: ${dir}`);
+                continue;
+            }
+            const filesToDelete = await getFilesToDelete(dir, excludePatterns, locale, cwd);
+            // Get all files for count comparison
+            const allFiles = await getAllFiles(dir);
+            for (const file of filesToDelete) {
+                try {
+                    await fs.unlink(file);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT') {
+                        logWarning(`Failed to delete file ${file}: ${error}`);
+                    }
+                }
+            }
+            // Clean up empty directories
+            await cleanupEmptyDirs(dir);
+            const excludedCount = allFiles.length - filesToDelete.length;
+            if (excludedCount > 0) {
+                logSuccess(`Cleared locale directory: ${dir} (excluded ${excludedCount} file${excludedCount > 1 ? 's' : ''})`);
+            }
+            else {
+                logSuccess(`Cleared locale directory: ${dir}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logWarning(`Failed to clear locale directory ${dir}: ${error}`);
+            }
+        }
+    }
+}
+/**
+ * Recursively removes empty directories
+ * @param dirPath - The directory to clean up
+ */
+async function cleanupEmptyDirs(dirPath) {
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        // Recursively clean subdirectories first
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                await cleanupEmptyDirs(path.join(dirPath, entry.name));
+            }
+        }
+        // Check if directory is now empty
+        const remainingEntries = await fs.readdir(dirPath);
+        if (remainingEntries.length === 0) {
+            await fs.rmdir(dirPath);
+        }
+    }
+    catch (error) {
+        // Ignore errors - directory might not exist or might not be empty
+    }
+}

package/dist/types/index.d.ts

@@ -143,6 +143,8 @@ export type AdditionalOptions = {
     excludeStaticImports?: string[];
     docsHideDefaultLocaleImport?: boolean;
     copyFiles?: string[];
+    experimentalClearLocaleDirs?: boolean;
+    clearLocaleDirsExclude?: string[];
     experimentalLocalizeStaticImports?: boolean;
     experimentalLocalizeStaticUrls?: boolean;
     experimentalAddHeaderAnchorIds?: 'mintlify';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.3.6",
+  "version": "2.3.8",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [