gtx-cli 2.3.10 → 2.3.12

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.3.12
+
+### Patch Changes
+
+- [#735](https://github.com/generaltranslation/gt/pull/735) [`8e4612e`](https://github.com/generaltranslation/gt/commit/8e4612e0b2c426d64153b6ca460e619fa29cb8e8) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - fix: auto enable gt compiler in default config
+
+## 2.3.11
+
+### Patch Changes
+
+- [#732](https://github.com/generaltranslation/gt/pull/732) [`bcd8272`](https://github.com/generaltranslation/gt/commit/bcd8272576ff02432e39cf1887a48b4f566eb752) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Added freezing when fetching translations for unmodified source files. This will keep any local changes until retranslation is triggered or --force-download is used
+
 ## 2.3.10
 
 ### Patch Changes

package/dist/api/checkFileTranslations.d.ts

@@ -20,4 +20,4 @@ export declare function checkFileTranslations(data: {
         versionId: string;
         fileName: string;
     };
-}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string | null, options: Settings, forceRetranslation?: boolean): Promise<boolean>;
+}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string | null, options: Settings, forceRetranslation?: boolean, forceDownload?: boolean): Promise<boolean>;

package/dist/api/checkFileTranslations.js

@@ -16,7 +16,7 @@ import path from 'node:path';
  * @param timeoutDuration - The timeout duration for the wait in seconds
  * @returns True if all translations are deployed, false otherwise
  */
-export async function checkFileTranslations(data, locales, timeoutDuration, resolveOutputPath, options, forceRetranslation) {
+export async function checkFileTranslations(data, locales, timeoutDuration, resolveOutputPath, options, forceRetranslation, forceDownload) {
     const startTime = Date.now();
     console.log();
     const spinner = await createOraSpinner();
@@ -49,7 +49,7 @@ export async function checkFileTranslations(data, locales, timeoutDuration, reso
     };
     // Do first check immediately, but skip if force retranslation is enabled
     if (!forceRetranslation) {
-        const initialCheck = await checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options);
+        const initialCheck = await checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options, forceDownload);
         if (initialCheck) {
             spinner.succeed(chalk.green('Files translated!'));
             return true;
@@ -62,7 +62,7 @@ export async function checkFileTranslations(data, locales, timeoutDuration, reso
         // Start the interval aligned with the original request time
         setTimeout(() => {
             intervalCheck = setInterval(async () => {
-                const isDeployed = await checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options);
+                const isDeployed = await checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options, forceDownload);
                 const elapsed = Date.now() - startTime;
                 if (isDeployed || elapsed >= timeoutDuration * 1000) {
                     clearInterval(intervalCheck);
@@ -186,7 +186,7 @@ function generateStatusSuffixText(downloadStatus, fileQueryData) {
 /**
  * Checks translation status and downloads ready files
  */
-async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options) {
+async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options, forceDownload) {
     try {
         // Only query for files that haven't been downloaded yet
         const currentQueryData = fileQueryData.filter((item) => !downloadStatus.downloaded.has(`${item.fileName}:${item.locale}`) &&
@@ -202,6 +202,11 @@ async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner
         // Filter for ready translations
         const readyTranslations = translations.filter((translation) => translation.isReady && translation.fileName);
         if (readyTranslations.length > 0) {
+            // Build version map by fileName:locale for this batch
+            const versionMap = new Map(fileQueryData.map((item) => [
+                `${item.fileName}:${gt.resolveAliasLocale(item.locale)}`,
+                item.versionId,
+            ]));
             // Prepare batch download data
             const batchFiles = readyTranslations
                 .map((translation) => {
@@ -220,10 +225,11 @@ async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner
                     outputPath,
                     locale,
                     fileLocale: `${fileName}:${locale}`,
+                    versionId: versionMap.get(`${fileName}:${locale}`),
                 };
             })
                 .filter((file) => file !== null);
-            const batchResult = await downloadFileBatch(batchFiles, options);
+            const batchResult = await downloadFileBatch(batchFiles, options, 3, 1000, Boolean(forceDownload));
             // Process results
             batchFiles.forEach((file) => {
                 const { translationId, fileLocale } = file;

package/dist/api/downloadFileBatch.d.ts

@@ -5,6 +5,8 @@ export type BatchedFiles = Array<{
     inputPath: string;
     locale: string;
     fileLocale: string;
+    fileId?: string;
+    versionId?: string;
 }>;
 export type DownloadFileBatchResult = {
     successful: string[];
@@ -17,4 +19,4 @@ export type DownloadFileBatchResult = {
  * @param retryDelay - Delay between retries in milliseconds
  * @returns Object containing successful and failed file IDs
  */
-export declare function downloadFileBatch(files: BatchedFiles, options: Settings, maxRetries?: number, retryDelay?: number): Promise<DownloadFileBatchResult>;
+export declare function downloadFileBatch(files: BatchedFiles, options: Settings, maxRetries?: number, retryDelay?: number, forceDownload?: boolean): Promise<DownloadFileBatchResult>;

package/dist/api/downloadFileBatch.js

@@ -6,6 +6,7 @@ import { validateJsonSchema } from '../formats/json/utils.js';
 import { validateYamlSchema } from '../formats/yaml/utils.js';
 import { mergeJson } from '../formats/json/mergeJson.js';
 import mergeYaml from '../formats/yaml/mergeYaml.js';
+import { getDownloadedVersions, saveDownloadedVersions, } from '../fs/config/downloadedVersions.js';
 /**
  * Downloads multiple translation files in a single batch request
  * @param files - Array of files to download with their output paths
@@ -13,17 +14,22 @@ import mergeYaml from '../formats/yaml/mergeYaml.js';
  * @param retryDelay - Delay between retries in milliseconds
  * @returns Object containing successful and failed file IDs
  */
-export async function downloadFileBatch(files, options, maxRetries = 3, retryDelay = 1000) {
+export async function downloadFileBatch(files, options, maxRetries = 3, retryDelay = 1000, forceDownload = false) {
+    // Local record of what version was last downloaded for each fileName:locale
+    const downloadedVersions = getDownloadedVersions(options.configDirectory);
+    let didUpdateDownloadedLock = false;
     let retries = 0;
     const fileIds = files.map((file) => file.translationId);
     const result = { successful: [], failed: [] };
     // Create a map of translationId to outputPath for easier lookup
     const outputPathMap = new Map(files.map((file) => [file.translationId, file.outputPath]));
     const inputPathMap = new Map(files.map((file) => [file.translationId, file.inputPath]));
+    const fileIdMap = new Map(files.map((file) => [file.translationId, file.fileId]));
     const localeMap = new Map(files.map((file) => [
         file.translationId,
         gt.resolveAliasLocale(file.locale),
     ]));
+    const versionMap = new Map(files.map((file) => [file.translationId, file.versionId]));
     while (retries <= maxRetries) {
         try {
             // Download the files
@@ -36,6 +42,8 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
                     const outputPath = outputPathMap.get(translationId);
                     const inputPath = inputPathMap.get(translationId);
                     const locale = localeMap.get(translationId);
+                    const fileId = fileIdMap.get(translationId);
+                    const versionId = versionMap.get(translationId);
                     if (!outputPath || !inputPath) {
                         logWarning(`No input/output path found for file: ${translationId}`);
                         result.failed.push(translationId);
@@ -46,6 +54,18 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
                     if (!fs.existsSync(dir)) {
                         fs.mkdirSync(dir, { recursive: true });
                     }
+                    // If a local translation already exists for the same source version, skip overwrite
+                    const keyId = fileId || inputPath;
+                    const downloadedKey = `${keyId}:${locale}`;
+                    const alreadyDownloadedVersion = downloadedVersions.entries[downloadedKey]?.versionId;
+                    const fileExists = fs.existsSync(outputPath);
+                    if (!forceDownload &&
+                        fileExists &&
+                        versionId &&
+                        alreadyDownloadedVersion === versionId) {
+                        result.successful.push(translationId);
+                        continue;
+                    }
                     let data = file.data;
                     if (options.options?.jsonSchema && locale) {
                         const jsonSchema = validateJsonSchema(options.options, inputPath);
@@ -78,6 +98,15 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
                     // Write the file to disk
                     await fs.promises.writeFile(outputPath, data);
                     result.successful.push(translationId);
+                    if (versionId) {
+                        downloadedVersions.entries[downloadedKey] = {
+                            versionId,
+                            fileId: fileId || undefined,
+                            fileName: inputPath,
+                            updatedAt: new Date().toISOString(),
+                        };
+                        didUpdateDownloadedLock = true;
+                    }
                 }
                 catch (error) {
                     logError(`Error saving file ${file.id}: ` + error);
@@ -91,6 +120,11 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
                     result.failed.push(fileId);
                 }
             }
+            // Persist any updates to the downloaded map at the end of a successful cycle
+            if (didUpdateDownloadedLock) {
+                saveDownloadedVersions(options.configDirectory, downloadedVersions);
+                didUpdateDownloadedLock = false;
+            }
             return result;
         }
         catch (error) {
@@ -100,6 +134,9 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
                     error);
                 // Mark all files as failed
                 result.failed = [...fileIds];
+                if (didUpdateDownloadedLock) {
+                    saveDownloadedVersions(options.configDirectory, downloadedVersions);
+                }
                 return result;
             }
             // Increment retry counter and wait before next attempt
@@ -109,5 +146,8 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
     }
     // Mark all files as failed if we get here
     result.failed = [...fileIds];
+    if (didUpdateDownloadedLock) {
+        saveDownloadedVersions(options.configDirectory, downloadedVersions);
+    }
     return result;
 }

package/dist/cli/commands/translate.js

@@ -15,7 +15,7 @@ export async function handleTranslate(options, settings, filesTranslationRespons
         const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
         const { data } = filesTranslationResponse;
         // Check for remaining translations
-        await checkFileTranslations(data, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings, options.force);
+        await checkFileTranslations(data, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings, options.force, options.forceDownload);
     }
 }
 // Downloads translations that were originally staged
@@ -33,8 +33,8 @@ export async function handleDownload(options, settings) {
     const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
     const stagedVersionData = await getStagedVersions(settings.configDirectory);
     // Check for remaining translations
-    await checkFileTranslations(stagedVersionData, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings, false // force is not applicable for downloading staged translations
-    );
+    await checkFileTranslations(stagedVersionData, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings, false, // force is not applicable for downloading staged translations
+    options.forceDownload);
 }
 export async function postProcessTranslations(settings) {
     // Localize static urls (/docs -> /[locale]/docs) and preserve anchor IDs for non-default locales

package/dist/cli/flags.js

@@ -26,6 +26,7 @@ export function attachTranslateFlags(command) {
         .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-download', 'Force download and overwrite local files, bypassing downloaded-versions checks.', false)
         .option('--experimental-clear-locale-dirs', 'Clear locale directories before downloading new translations', false);
     return command;
 }

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

@@ -0,0 +1,12 @@
+export type DownloadedVersionEntry = {
+    versionId: string;
+    fileId?: string;
+    fileName?: string;
+    updatedAt?: string;
+};
+export type DownloadedVersions = {
+    version: number;
+    entries: Record<string, DownloadedVersionEntry>;
+};
+export declare function getDownloadedVersions(configDirectory: string): DownloadedVersions;
+export declare function saveDownloadedVersions(configDirectory: string, lock: DownloadedVersions): void;

package/dist/fs/config/downloadedVersions.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logError } from '../../console/logging.js';
+const DOWNLOADED_VERSIONS_FILE = 'downloaded-versions.json';
+export function getDownloadedVersions(configDirectory) {
+    try {
+        const filepath = path.join(configDirectory, DOWNLOADED_VERSIONS_FILE);
+        if (!fs.existsSync(filepath))
+            return { version: 1, entries: {} };
+        const raw = JSON.parse(fs.readFileSync(filepath, 'utf8'));
+        if (raw && typeof raw === 'object' && raw.version && raw.entries) {
+            return raw;
+        }
+        return { version: 1, entries: {} };
+    }
+    catch (error) {
+        logError(`An error occurred while getting downloaded versions: ${error}`);
+        return { version: 1, entries: {} };
+    }
+}
+export function saveDownloadedVersions(configDirectory, lock) {
+    try {
+        const filepath = path.join(configDirectory, DOWNLOADED_VERSIONS_FILE);
+        fs.mkdirSync(configDirectory, { recursive: true });
+        fs.writeFileSync(filepath, JSON.stringify(lock, null, 2));
+    }
+    catch (error) {
+        logError(`An error occurred while updating ${DOWNLOADED_VERSIONS_FILE}: ${error}`);
+    }
+}

package/dist/next/parse/handleInitGT.js

@@ -7,6 +7,7 @@ const traverse = traverseModule.default || traverseModule;
 const generate = generateModule.default || generateModule;
 import * as t from '@babel/types';
 import { logError } from '../../console/logging.js';
+import { needsCJS } from '../../utils/parse/needsCJS.js';
 export async function handleInitGT(filepath, errors, warnings, filesUpdated, packageJson, tsconfigJson) {
     const code = await fs.promises.readFile(filepath, 'utf8');
     let ast;
@@ -17,66 +18,14 @@ export async function handleInitGT(filepath, errors, warnings, filesUpdated, pac
             tokens: true,
             createParenthesizedExpressions: true,
         });
-        // Analyze the actual file content to determine module system
-        let hasES6Imports = false;
-        let hasCommonJSRequire = false;
-        traverse(ast, {
-            ImportDeclaration() {
-                hasES6Imports = true;
-            },
-            CallExpression(path) {
-                if (t.isIdentifier(path.node.callee, { name: 'require' })) {
-                    hasCommonJSRequire = true;
-                }
-            },
+        // Get cjs or esm
+        const cjsEnabled = needsCJS({
+            ast,
+            warnings,
+            filepath,
+            packageJson,
+            tsconfigJson,
         });
-        // Determine if we need CommonJS based on actual file content and fallback to config-based logic
-        let needsCJS = false;
-        if (hasES6Imports && !hasCommonJSRequire) {
-            // File uses ES6 imports, so we should use ES6 imports
-            needsCJS = false;
-        }
-        else if (hasCommonJSRequire && !hasES6Imports) {
-            // File uses CommonJS require, so we should use CommonJS require
-            needsCJS = true;
-        }
-        else if (hasES6Imports && hasCommonJSRequire) {
-            // Mixed usage - this is unusual but we'll default to ES6 imports
-            warnings.push(`Mixed ES6 imports and CommonJS require detected in ${filepath}. Defaulting to ES6 imports.`);
-            needsCJS = false;
-        }
-        else {
-            // No imports/requires found, fall back to configuration-based logic
-            if (filepath.endsWith('.ts') || filepath.endsWith('.tsx')) {
-                // For TypeScript files, check tsconfig.json compilerOptions.module
-                const moduleSetting = tsconfigJson?.compilerOptions?.module;
-                if (moduleSetting === 'commonjs' || moduleSetting === 'node') {
-                    needsCJS = true;
-                }
-                else if (moduleSetting === 'esnext' ||
-                    moduleSetting === 'es2022' ||
-                    moduleSetting === 'es2020' ||
-                    moduleSetting === 'es2015' ||
-                    moduleSetting === 'es6' ||
-                    moduleSetting === 'node16' ||
-                    moduleSetting === 'nodenext') {
-                    needsCJS = false;
-                }
-                else {
-                    // Default to ESM for TypeScript files if no module setting is specified
-                    needsCJS = false;
-                }
-            }
-            else if (filepath.endsWith('.js')) {
-                // For JavaScript files, check package.json type
-                // If package.json has "type": "module", .js files are treated as ES modules
-                needsCJS = packageJson?.type !== 'module';
-            }
-            else {
-                // For other file extensions, default to ESM
-                needsCJS = false;
-            }
-        }
         // Check if withGTConfig or initGT is already imported/required
         let hasGTConfig = false;
         let hasInitGT = false;
@@ -145,7 +94,7 @@ export async function handleInitGT(filepath, errors, warnings, filesUpdated, pac
         if (hasGTConfig || hasInitGT) {
             return;
         }
-        ast.program.body.unshift(needsCJS
+        ast.program.body.unshift(cjsEnabled
             ? t.variableDeclaration('const', [
                 t.variableDeclarator(t.identifier('withGTConfig'), t.memberExpression(t.callExpression(t.identifier('require'), [
                     t.stringLiteral('gt-next/config'),

package/dist/react/parse/addVitePlugin/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Adds the gt compiler plugin to the vite config file
+ */
+export declare function addVitePlugin({ errors, warnings, filesUpdated, packageJson, tsconfigJson, }: {
+    errors: string[];
+    warnings: string[];
+    filesUpdated: string[];
+    packageJson?: {
+        type?: string;
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+    };
+    tsconfigJson?: {
+        compilerOptions?: {
+            module?: string;
+        };
+    };
+}): Promise<{
+    errors: string[];
+    warnings: string[];
+    filesUpdated: string[];
+}>;

package/dist/react/parse/addVitePlugin/index.js

@@ -0,0 +1,40 @@
+import findFilepath from '../../../fs/findFilepath.js';
+import { logError } from '../../../console/logging.js';
+import { installCompiler } from './installCompiler.js';
+import { updateViteConfig } from './updateViteConfig.js';
+const VITE_CONFIG_PATH_BASE = './vite.config.';
+/**
+ * Adds the gt compiler plugin to the vite config file
+ */
+export async function addVitePlugin({ errors, warnings, filesUpdated, packageJson, tsconfigJson, }) {
+    // Resolve file path
+    const viteConfigPath = findFilepath([
+        VITE_CONFIG_PATH_BASE + 'js',
+        VITE_CONFIG_PATH_BASE + 'ts',
+        VITE_CONFIG_PATH_BASE + 'mjs',
+        VITE_CONFIG_PATH_BASE + 'mts',
+        VITE_CONFIG_PATH_BASE + 'cjs',
+        VITE_CONFIG_PATH_BASE + 'cts',
+    ]);
+    if (!viteConfigPath) {
+        logError(`No ${VITE_CONFIG_PATH_BASE}[js|ts|mjs|mts|cjs|cts] file found. Please add the @generaltranslation/compiler plugin to your vite configuration file:
+      import { vite as gtCompiler } from '@generaltranslation/compiler';
+      export default defineConfig({
+        plugins: [gtCompiler()],
+      });
+      `);
+        process.exit(1);
+    }
+    // Install @generaltranslation/compiler if not installed
+    await installCompiler({ packageJson });
+    // Update the config file
+    await updateViteConfig({
+        errors,
+        warnings,
+        filesUpdated,
+        viteConfigPath,
+        packageJson,
+        tsconfigJson,
+    });
+    return { errors, warnings, filesUpdated };
+}

package/dist/react/parse/addVitePlugin/installCompiler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Installs @generaltranslation/compiler if not installed
+ */
+export declare function installCompiler({ packageJson, }: {
+    packageJson?: {
+        type?: string;
+    };
+}): Promise<void>;

package/dist/react/parse/addVitePlugin/installCompiler.js

@@ -0,0 +1,22 @@
+import { createSpinner } from '../../../console/logging.js';
+import { installPackage } from '../../../utils/installPackage.js';
+import { isPackageInstalled } from '../../../utils/packageJson.js';
+import { getPackageManager } from '../../../utils/packageManager.js';
+import chalk from 'chalk';
+/**
+ * Installs @generaltranslation/compiler if not installed
+ */
+export async function installCompiler({ packageJson, }) {
+    // Check if installed
+    if (isPackageInstalled('@generaltranslation/compiler', packageJson || {})) {
+        return;
+    }
+    // Animation
+    const spinner = createSpinner();
+    spinner.start(`Installing @generaltranslation/compiler...`);
+    // Install
+    const packageManager = await getPackageManager();
+    await installPackage('@generaltranslation/compiler', packageManager, true);
+    // Animation
+    spinner.stop(chalk.green('Installed @generaltranslation/compiler.'));
+}

package/dist/react/parse/addVitePlugin/updateViteConfig.d.ts

@@ -0,0 +1,19 @@
+/**
+ * - Reads the vite config file
+ * - Updates the ast to add the gt compiler plugin
+ * - Writes the file back to the filesystem
+ */
+export declare function updateViteConfig({ errors, warnings, filesUpdated, viteConfigPath, packageJson, tsconfigJson, }: {
+    errors: string[];
+    warnings: string[];
+    filesUpdated: string[];
+    viteConfigPath: string;
+    packageJson?: {
+        type?: string;
+    };
+    tsconfigJson?: {
+        compilerOptions?: {
+            module?: string;
+        };
+    };
+}): Promise<void>;

package/dist/react/parse/addVitePlugin/updateViteConfig.js

@@ -0,0 +1,123 @@
+import { createSpinner } from '../../../console/logging.js';
+import { logError } from '../../../console/logging.js';
+import fs from 'node:fs';
+import chalk from 'chalk';
+import generateModule from '@babel/generator';
+import { parse } from '@babel/parser';
+import { needsCJS } from '../../../utils/parse/needsCJS.js';
+import { addCompilerImport } from './utils/addCompilerImport.js';
+import { checkCompilerImport } from './utils/checkCompilerImport.js';
+import { checkPluginInvocation } from './utils/checkPluginInvocation.js';
+import { addPluginInvocation } from './utils/addPluginInvocation.js';
+// Handle CommonJS/ESM interop
+const generate = generateModule.default || generateModule;
+/**
+ * - Reads the vite config file
+ * - Updates the ast to add the gt compiler plugin
+ * - Writes the file back to the filesystem
+ */
+export async function updateViteConfig({ errors, warnings, filesUpdated, viteConfigPath, packageJson, tsconfigJson, }) {
+    // Animation
+    const spinner = createSpinner();
+    spinner.start(`Adding gt compiler plugin to ${viteConfigPath}...`);
+    // Read the file
+    let code;
+    try {
+        code = await fs.promises.readFile(viteConfigPath, 'utf8');
+    }
+    catch (error) {
+        logError(`Error: Failed to read ${viteConfigPath}: ${error}`);
+        process.exit(1);
+        return;
+    }
+    // Update the ast
+    let updatedCode, success;
+    try {
+        ({ updatedCode, success } = await updateViteConfigAst({
+            code,
+            errors,
+            warnings,
+            viteConfigPath,
+            packageJson,
+            tsconfigJson,
+        }));
+    }
+    catch (error) {
+        logError(`Error: Failed to update ${viteConfigPath}: ${error}`);
+        process.exit(1);
+        return;
+    }
+    // Write the file
+    try {
+        await fs.promises.writeFile(viteConfigPath, updatedCode);
+        filesUpdated.push(viteConfigPath);
+    }
+    catch (error) {
+        logError(`Error: Failed to write ${viteConfigPath}: ${error}`);
+        process.exit(1);
+        return;
+    }
+    // Animation
+    spinner.stop(success
+        ? chalk.green(`Success! Added gt compiler plugin to ${viteConfigPath}`)
+        : chalk.red(`Failed to add gt compiler plugin to ${viteConfigPath}. Continuing setup...`));
+}
+/**
+ * Orchestrates AST manipulation
+ * @param code - The code to update
+ * @param errors - The errors to update
+ * @param warnings - The warnings to update
+ * @param viteConfigPath - The path to the vite config file
+ * @param packageJson - The package.json file
+ * @param tsconfigJson - The tsconfig.json file
+ * @returns
+ */
+async function updateViteConfigAst({ code, warnings, viteConfigPath, packageJson, tsconfigJson, }) {
+    // Parse the code
+    const ast = parse(code, {
+        sourceType: 'module',
+        plugins: ['jsx', 'typescript'],
+    });
+    // Get cjs or esm
+    const cjsEnabled = needsCJS({
+        ast,
+        warnings,
+        filepath: viteConfigPath,
+        packageJson,
+        tsconfigJson,
+    });
+    // Check if the compiler import is already present
+    let { hasCompilerImport, alias, namespaces } = checkCompilerImport(ast);
+    // Add the import declaration
+    if (!hasCompilerImport) {
+        addCompilerImport({ ast, cjsEnabled });
+        hasCompilerImport = true;
+        alias = 'gtCompiler';
+        namespaces = [];
+    }
+    // Check if plugin is already present
+    let pluginAlreadyPresent = false;
+    if (hasCompilerImport) {
+        pluginAlreadyPresent = checkPluginInvocation({ ast, alias, namespaces });
+    }
+    // Insert plugin invocation
+    let success = false;
+    if (!pluginAlreadyPresent) {
+        success = addPluginInvocation({ ast, alias, namespaces });
+        if (!success) {
+            warnings.push(`Failed to add gt compiler plugin to ${viteConfigPath}. Please add the plugin manually:
+import { vite as gtCompiler } from '@generaltranslation/compiler';
+export default defineConfig({
+  plugins: [gtCompiler()],
+});`);
+        }
+    }
+    // Generate the modified code
+    const output = generate(ast, {
+        retainLines: true,
+        retainFunctionParens: true,
+        comments: true,
+        compact: 'auto',
+    }, code);
+    return { updatedCode: output.code, success };
+}

package/dist/react/parse/addVitePlugin/utils/addCompilerImport.d.ts

@@ -0,0 +1,9 @@
+import { ParseResult } from '@babel/parser';
+import * as t from '@babel/types';
+/**
+ * Given the vite config file ast, inserts the import declaration for the @generaltranslation/compiler package
+ */
+export declare function addCompilerImport({ ast, cjsEnabled, }: {
+    ast: ParseResult<t.File>;
+    cjsEnabled: boolean;
+}): void;

package/dist/react/parse/addVitePlugin/utils/addCompilerImport.js

@@ -0,0 +1,34 @@
+import * as t from '@babel/types';
+/**
+ * Given the vite config file ast, inserts the import declaration for the @generaltranslation/compiler package
+ */
+export function addCompilerImport({ ast, cjsEnabled, }) {
+    if (cjsEnabled) {
+        handleCjsImport(ast);
+    }
+    else {
+        handleEsmImport(ast);
+    }
+}
+/**
+ * Adds a CJS import declaration for the @generaltranslation/compiler package
+ * @param ast - The ast of the file
+ * const gtCompiler = require('@generaltranslation/compiler').vite;
+ */
+function handleCjsImport(ast) {
+    const variableDeclaration = t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('gtCompiler'), t.memberExpression(t.callExpression(t.identifier('require'), [
+            t.stringLiteral('@generaltranslation/compiler'),
+        ]), t.identifier('vite'))),
+    ]);
+    ast.program.body.unshift(variableDeclaration);
+}
+/**
+ * Adds an ESM import declaration for the @generaltranslation/compiler package
+ * @param ast - The ast of the file
+ * import { vite as gtCompiler } from '@generaltranslation/compiler';
+ */
+function handleEsmImport(ast) {
+    const importDeclaration = t.importDeclaration([t.importSpecifier(t.identifier('gtCompiler'), t.identifier('vite'))], t.stringLiteral('@generaltranslation/compiler'));
+    ast.program.body.unshift(importDeclaration);
+}

package/dist/react/parse/addVitePlugin/utils/addPluginInvocation.d.ts

@@ -0,0 +1,11 @@
+import * as t from '@babel/types';
+import { ParseResult } from '@babel/parser';
+/**
+ * Adds the plugin invocation to the vite config file
+ * Naive solution: look for an object with a plugins property only inside of a defineConfig call
+ */
+export declare function addPluginInvocation({ ast, alias, namespaces, }: {
+    ast: ParseResult<t.File>;
+    alias: string | null;
+    namespaces: string[];
+}): boolean;

package/dist/react/parse/addVitePlugin/utils/addPluginInvocation.js

@@ -0,0 +1,48 @@
+import * as t from '@babel/types';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+/**
+ * Adds the plugin invocation to the vite config file
+ * Naive solution: look for an object with a plugins property only inside of a defineConfig call
+ */
+export function addPluginInvocation({ ast, alias, namespaces, }) {
+    let addedPlugin = false;
+    if (namespaces.length === 0 && !alias) {
+        return false;
+    }
+    const pluginInvocation = alias
+        ? t.callExpression(t.identifier(alias), [])
+        : t.callExpression(t.memberExpression(t.identifier(namespaces[0]), t.identifier('vite')), []);
+    traverse(ast, {
+        CallExpression(path) {
+            if (!t.isIdentifier(path.node.callee, { name: 'defineConfig' }) ||
+                !path.node.arguments.length ||
+                !t.isObjectExpression(path.node.arguments[0])) {
+                return;
+            }
+            for (const property of path.node.arguments[0].properties) {
+                if (!t.isObjectProperty(property) || !isPluginsProperty(property))
+                    continue;
+                if (t.isArrayExpression(property.value)) {
+                    // Add to array: [react()] -> [react(), gtCompiler()]
+                    property.value.elements.push(pluginInvocation);
+                    addedPlugin = true;
+                }
+                else {
+                    // Spread the array: someList -> [...someList, gtCompiler()]
+                    property.value = t.arrayExpression([
+                        t.spreadElement(property.value),
+                        pluginInvocation,
+                    ]);
+                    addedPlugin = true;
+                }
+            }
+        },
+    });
+    return addedPlugin;
+}
+function isPluginsProperty(node) {
+    return (t.isIdentifier(node.key, { name: 'plugins' }) ||
+        t.isStringLiteral(node.key, { value: 'plugins' }));
+}

package/dist/react/parse/addVitePlugin/utils/checkCompilerImport.d.ts

@@ -0,0 +1,15 @@
+import { ParseResult } from '@babel/parser';
+import * as t from '@babel/types';
+export interface CheckCompilerImportResult {
+    hasCompilerImport: boolean;
+    alias: string | null;
+    namespaces: string[];
+}
+/**
+ * Given the vite config file ast, checks if the @generaltranslation/compiler package is imported.
+ * If it is imported, capture any aliases or namespace.
+ *
+ * Does not handle:
+ * - Nested expressions
+ */
+export declare function checkCompilerImport(ast: ParseResult<t.File>): CheckCompilerImportResult;

package/dist/react/parse/addVitePlugin/utils/checkCompilerImport.js

@@ -0,0 +1,113 @@
+import * as t from '@babel/types';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+/**
+ * Given the vite config file ast, checks if the @generaltranslation/compiler package is imported.
+ * If it is imported, capture any aliases or namespace.
+ *
+ * Does not handle:
+ * - Nested expressions
+ */
+export function checkCompilerImport(ast) {
+    const result = {
+        hasCompilerImport: false,
+        alias: null,
+        namespaces: [],
+    };
+    traverse(ast, {
+        ImportDeclaration(path) {
+            handleImportDeclaration(path, result);
+        },
+        VariableDeclaration(path) {
+            handleVariableDeclaration(path, result);
+        },
+    });
+    return result;
+}
+/* =============================== */
+/* Parsing Functions */
+/* =============================== */
+/**
+ * Checks an import declaration for a compiler import
+ * @param path - The import declaration path
+ * @param result - The result object
+ */
+function handleImportDeclaration(path, result) {
+    if (path.node.source.value !== '@generaltranslation/compiler')
+        return;
+    for (const spec of path.node.specifiers) {
+        if (t.isImportSpecifier(spec)) {
+            // Handle named import: import { vite as gtCompiler } from '@generaltranslation/compiler'
+            if (t.isIdentifier(spec.imported) && spec.imported.name === 'vite') {
+                result.hasCompilerImport = true;
+                result.alias = spec.local.name;
+            }
+        }
+        else {
+            // Handle default import: import gtCompiler from '@generaltranslation/compiler'
+            // Handle namespace import: import * as gtCompiler from '@generaltranslation/compiler'
+            result.hasCompilerImport = true;
+            result.namespaces.push(spec.local.name);
+        }
+    }
+}
+/**
+ * Handles a variable declaration for a compiler import
+ * @param path - The variable declaration path
+ * @param result - The result object
+ */
+function handleVariableDeclaration(path, result) {
+    path.node.declarations.forEach((dec) => {
+        // Handle destructuring: const { withGTConfig } = require('@generaltranslation/compiler')
+        if (t.isCallExpression(dec.init) &&
+            t.isIdentifier(dec.init.callee, { name: 'require' }) &&
+            t.isStringLiteral(dec.init.arguments[0], {
+                value: '@generaltranslation/compiler',
+            })) {
+            if (t.isIdentifier(dec.id)) {
+                // Handle namespace assignment: const gtCompiler = require('@generaltranslation/compiler')
+                result.hasCompilerImport = true;
+                result.namespaces.push(dec.id.name);
+            }
+            else if (t.isObjectPattern(dec.id)) {
+                // Handle destructuring: const { vite: gtCompiler } = require('@generaltranslation/compiler')
+                let foundVite = false;
+                const restElements = [];
+                for (const prop of dec.id.properties) {
+                    if (t.isObjectProperty(prop) &&
+                        t.isIdentifier(prop.key) &&
+                        t.isIdentifier(prop.value) &&
+                        prop.key.name === 'vite') {
+                        // Handle destructing alias assignment: const { vite: gtCompiler } = require('@generaltranslation/compiler')
+                        result.hasCompilerImport = true;
+                        result.alias = prop.value.name;
+                        foundVite = true;
+                        break;
+                    }
+                    else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+                        // Track list of rest elements
+                        restElements.push(prop.argument.name);
+                    }
+                }
+                // Handle destructuring rest elements: const { ...some, b, ...others, d } = require('@generaltranslation/compiler')
+                if (!foundVite && restElements.length > 0) {
+                    result.hasCompilerImport = true;
+                    result.namespaces.push(...restElements);
+                }
+            }
+        }
+        else if (t.isMemberExpression(dec.init) &&
+            t.isCallExpression(dec.init.object) &&
+            t.isIdentifier(dec.init.object.callee, { name: 'require' }) &&
+            t.isStringLiteral(dec.init.object.arguments[0], {
+                value: '@generaltranslation/compiler',
+            }) &&
+            t.isIdentifier(dec.init.property, { name: 'vite' }) &&
+            t.isIdentifier(dec.id)) {
+            // Handle member access: const gtCompiler = require('@generaltranslation/compiler').vite
+            result.hasCompilerImport = true;
+            result.alias = dec.id.name;
+        }
+    });
+}

package/dist/react/parse/addVitePlugin/utils/checkPluginInvocation.d.ts

@@ -0,0 +1,12 @@
+import { ParseResult } from '@babel/parser';
+import * as t from '@babel/types';
+/**
+ * Checks if the given AST is exporting the gtCompiler plugin
+ *
+ * Naive check: see if the plugin has been invoked anywhere in the file
+ */
+export declare function checkPluginInvocation({ ast, alias, namespaces, }: {
+    ast: ParseResult<t.File>;
+    alias: string | null;
+    namespaces: string[];
+}): boolean;

package/dist/react/parse/addVitePlugin/utils/checkPluginInvocation.js

@@ -0,0 +1,32 @@
+import * as t from '@babel/types';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+/**
+ * Checks if the given AST is exporting the gtCompiler plugin
+ *
+ * Naive check: see if the plugin has been invoked anywhere in the file
+ */
+export function checkPluginInvocation({ ast, alias, namespaces, }) {
+    let result = false;
+    traverse(ast, {
+        CallExpression(path) {
+            // Handle: gtCompiler()
+            if (!alias)
+                return;
+            if (t.isIdentifier(path.node.callee, { name: alias })) {
+                result = true;
+            }
+        },
+        MemberExpression(path) {
+            // Handle: gtCompiler.vite()
+            if (t.isIdentifier(path.node.object) &&
+                namespaces.includes(path.node.object.name) &&
+                t.isCallExpression(path.parent) &&
+                t.isIdentifier(path.node.property, { name: 'vite' })) {
+                result = true;
+            }
+        },
+    });
+    return result;
+}

package/dist/setup/wizard.js

@@ -12,6 +12,7 @@ import { getPackageManager } from '../utils/packageManager.js';
 import { installPackage } from '../utils/installPackage.js';
 import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
 import { loadConfig } from '../fs/config/loadConfig.js';
+import { addVitePlugin } from '../react/parse/addVitePlugin/index.js';
 export async function handleSetupReactCommand(options) {
     // Ask user for confirmation using inquirer
     const answer = await promptConfirm({
@@ -73,6 +74,9 @@ Please let us know what you would like to see supported at https://github.com/ge
     const errors = [];
     const warnings = [];
     let filesUpdated = [];
+    // Read tsconfig.json if it exists
+    const tsconfigPath = findFilepath(['tsconfig.json']);
+    const tsconfigJson = tsconfigPath ? loadConfig(tsconfigPath) : undefined;
     if (frameworkType === 'next-app') {
         // Check if they have a next.config.js file
         const nextConfigPath = findFilepath([
@@ -98,13 +102,20 @@ Please let us know what you would like to see supported at https://github.com/ge
         const { filesUpdated: filesUpdatedNext } = await wrapContentNext(mergeOptions, 'gt-next', errors, warnings);
         filesUpdated = [...filesUpdated, ...filesUpdatedNext];
         spinner.stop(chalk.green(`Success! Updated ${chalk.bold.cyan(filesUpdated.length)} files:\n`) + filesUpdated.map((file) => `${chalk.green('-')} ${file}`).join('\n'));
-        // Read tsconfig.json if it exists
-        const tsconfigPath = findFilepath(['tsconfig.json']);
-        const tsconfigJson = tsconfigPath ? loadConfig(tsconfigPath) : undefined;
         // Add the withGTConfig() function to the next.config.js file
         await handleInitGT(nextConfigPath, errors, warnings, filesUpdated, packageJson, tsconfigJson);
         logStep(chalk.green(`Added withGTConfig() to your ${nextConfigPath} file.`));
     }
+    // Add gt compiler plugin
+    if (frameworkType === 'vite') {
+        await addVitePlugin({
+            errors,
+            warnings,
+            filesUpdated,
+            packageJson,
+            tsconfigJson,
+        });
+    }
     if (errors.length > 0) {
         logError(chalk.red('Failed to write files:\n') + errors.join('\n'));
     }

package/dist/types/index.d.ts

@@ -41,6 +41,7 @@ export type TranslateFlags = {
     stageTranslations?: boolean;
     publish?: boolean;
     force?: boolean;
+    forceDownload?: boolean;
     experimentalLocalizeStaticUrls?: boolean;
     experimentalHideDefaultLocale?: boolean;
     experimentalFlattenJsonFiles?: boolean;

package/dist/utils/parse/needsCJS.d.ts

@@ -0,0 +1,20 @@
+import { ParseResult } from '@babel/parser';
+import * as t from '@babel/types';
+/**
+ * Given an AST determines if the file needs to be compiled as CommonJS or ESM.
+ * @param ast - The AST to analyze
+ * @returns True if the file needs to be compiled as CommonJS, false if it needs to be compiled as ESM
+ */
+export declare function needsCJS({ ast, warnings, filepath, packageJson, tsconfigJson, }: {
+    ast: ParseResult<t.File>;
+    warnings: string[];
+    filepath: string;
+    packageJson?: {
+        type?: string;
+    };
+    tsconfigJson?: {
+        compilerOptions?: {
+            module?: string;
+        };
+    };
+}): boolean;

package/dist/utils/parse/needsCJS.js

@@ -0,0 +1,72 @@
+import traverseModule from '@babel/traverse';
+import * as t from '@babel/types';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+/**
+ * Given an AST determines if the file needs to be compiled as CommonJS or ESM.
+ * @param ast - The AST to analyze
+ * @returns True if the file needs to be compiled as CommonJS, false if it needs to be compiled as ESM
+ */
+export function needsCJS({ ast, warnings, filepath, packageJson, tsconfigJson, }) {
+    // Analyze the actual file content to determine module system
+    let hasES6Imports = false;
+    let hasCommonJSRequire = false;
+    traverse(ast, {
+        ImportDeclaration() {
+            hasES6Imports = true;
+        },
+        CallExpression(path) {
+            if (t.isIdentifier(path.node.callee, { name: 'require' })) {
+                hasCommonJSRequire = true;
+            }
+        },
+    });
+    // Determine if we need CommonJS based on actual file content and fallback to config-based logic
+    let needsCJS = false;
+    if (hasES6Imports && !hasCommonJSRequire) {
+        // File uses ES6 imports, so we should use ES6 imports
+        needsCJS = false;
+    }
+    else if (hasCommonJSRequire && !hasES6Imports) {
+        // File uses CommonJS require, so we should use CommonJS require
+        needsCJS = true;
+    }
+    else if (hasES6Imports && hasCommonJSRequire) {
+        // Mixed usage - this is unusual but we'll default to ES6 imports
+        warnings.push(`Mixed ES6 imports and CommonJS require detected in ${filepath}. Defaulting to ES6 imports.`);
+        needsCJS = false;
+    }
+    else {
+        // No imports/requires found, fall back to configuration-based logic
+        if (filepath.endsWith('.ts') || filepath.endsWith('.tsx')) {
+            // For TypeScript files, check tsconfig.json compilerOptions.module
+            const moduleSetting = tsconfigJson?.compilerOptions?.module;
+            if (moduleSetting === 'commonjs' || moduleSetting === 'node') {
+                needsCJS = true;
+            }
+            else if (moduleSetting === 'esnext' ||
+                moduleSetting === 'es2022' ||
+                moduleSetting === 'es2020' ||
+                moduleSetting === 'es2015' ||
+                moduleSetting === 'es6' ||
+                moduleSetting === 'node16' ||
+                moduleSetting === 'nodenext') {
+                needsCJS = false;
+            }
+            else {
+                // Default to ESM for TypeScript files if no module setting is specified
+                needsCJS = false;
+            }
+        }
+        else if (filepath.endsWith('.js')) {
+            // For JavaScript files, check package.json type
+            // If package.json has "type": "module", .js files are treated as ES modules
+            needsCJS = packageJson?.type !== 'module';
+        }
+        else {
+            // For other file extensions, default to ESM
+            needsCJS = false;
+        }
+    }
+    return needsCJS;
+}

package/package.json

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