gtx-cli 1.0.3-alpha.1 → 1.1.0-alpha.1

package/dist/api/checkFileTranslations.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks the status of translations for a given version ID
+ * @param apiKey - The API key for the General Translation API
+ * @param baseUrl - The base URL for the General Translation API
+ * @param versionId - The version ID of the project
+ * @param locales - The locales to wait for
+ * @param startTime - The start time of the wait
+ * @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: {
+    [key: string]: {
+        versionId: string;
+        canonicalName: string;
+    };
+}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string): Promise<boolean>;

package/dist/api/checkFileTranslations.js

@@ -0,0 +1,167 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFileTranslations = checkFileTranslations;
+const chalk_1 = __importDefault(require("chalk"));
+const console_1 = require("../console/console");
+const generaltranslation_1 = require("generaltranslation");
+const downloadFile_1 = require("./downloadFile");
+/**
+ * Checks the status of translations for a given version ID
+ * @param apiKey - The API key for the General Translation API
+ * @param baseUrl - The base URL for the General Translation API
+ * @param versionId - The version ID of the project
+ * @param locales - The locales to wait for
+ * @param startTime - The start time of the wait
+ * @param timeoutDuration - The timeout duration for the wait in seconds
+ * @returns True if all translations are deployed, false otherwise
+ */
+function checkFileTranslations(apiKey, baseUrl, data, locales, timeoutDuration, resolveOutputPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const startTime = Date.now();
+        const spinner = yield (0, console_1.displayLoadingAnimation)('Waiting for translation...');
+        const downloadedFiles = new Set(); // Track which file+locale combinations have been downloaded
+        let fileQueryData = [];
+        // Initialize the query data
+        for (const file in data) {
+            for (const locale of locales) {
+                fileQueryData.push({
+                    versionId: data[file].versionId,
+                    fileName: data[file].canonicalName,
+                    locale,
+                });
+            }
+        }
+        const checkDeployment = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Only query for files that haven't been downloaded yet
+                const currentQueryData = fileQueryData.filter((item) => !downloadedFiles.has(`${item.fileName}:${item.locale}`));
+                // If all files have been downloaded, we're done
+                if (currentQueryData.length === 0) {
+                    return true;
+                }
+                const response = yield fetch(`${baseUrl}/v1/project/translations/files/retrieve`, {
+                    method: 'POST',
+                    headers: Object.assign({ 'Content-Type': 'application/json' }, (apiKey && { 'x-gt-api-key': apiKey })),
+                    body: JSON.stringify({ files: currentQueryData }),
+                });
+                if (response.ok) {
+                    const responseData = yield response.json();
+                    const translations = responseData.translations || [];
+                    // Process available translations
+                    for (const translation of translations) {
+                        const locale = translation.locale;
+                        const fileName = data[translation.fileName].canonicalName;
+                        if (translation.isReady && fileName) {
+                            // Mark this file+locale as downloaded
+                            downloadedFiles.add(`${fileName}:${locale}`);
+                            // Download the file
+                            const outputPath = resolveOutputPath(fileName, locale);
+                            yield (0, downloadFile_1.downloadFile)(baseUrl, apiKey, translation.fileId, outputPath);
+                        }
+                    }
+                    // Update the spinner text
+                    spinner.suffixText = generateStatusSuffixText(downloadedFiles, fileQueryData);
+                }
+                if (downloadedFiles.size === fileQueryData.length) {
+                    return true;
+                }
+                return false;
+            }
+            catch (error) {
+                console.error('Error checking translation status:', error);
+                return false;
+            }
+        });
+        /**
+         * Generates a formatted status text showing translation progress
+         * @param downloadedFiles - Set of downloaded file+locale combinations
+         * @param fileQueryData - Array of file query data objects
+         * @returns Formatted status text
+         */
+        function generateStatusSuffixText(downloadedFiles, fileQueryData) {
+            var _a;
+            const newSuffixText = [
+                `\n\n` +
+                    chalk_1.default.green(`${downloadedFiles.size}/${fileQueryData.length}`) +
+                    ` translations completed\n`,
+            ];
+            // Group by filename for better organization
+            const fileGroups = new Map();
+            // Initialize with all files and locales from fileQueryData
+            for (const item of fileQueryData) {
+                if (!fileGroups.has(item.fileName)) {
+                    fileGroups.set(item.fileName, new Set());
+                }
+                (_a = fileGroups.get(item.fileName)) === null || _a === void 0 ? void 0 : _a.add(item.locale);
+            }
+            // Mark which ones are completed
+            for (const fileLocale of downloadedFiles) {
+                const [fileName, locale] = fileLocale.split(':');
+                const completedLocales = fileGroups.get(fileName);
+                if (completedLocales) {
+                    completedLocales.delete(locale); // Remove from pending
+                }
+            }
+            // Display each file with its status
+            for (const [fileName, pendingLocales] of fileGroups.entries()) {
+                newSuffixText.push(`\n${chalk_1.default.bold(fileName)}`);
+                // Show completed locales for this file
+                for (const fileLocale of downloadedFiles) {
+                    const [currentFileName, locale] = fileLocale.split(':');
+                    if (currentFileName === fileName) {
+                        const localeProperties = (0, generaltranslation_1.getLocaleProperties)(locale);
+                        newSuffixText.push(`  ${chalk_1.default.green('✓')} ${chalk_1.default.green(localeProperties.code)}`);
+                    }
+                }
+                // Show pending locales for this file
+                for (const locale of pendingLocales) {
+                    const localeProperties = (0, generaltranslation_1.getLocaleProperties)(locale);
+                    newSuffixText.push(`  ${chalk_1.default.yellow('[==>')} ${chalk_1.default.yellow(localeProperties.code)}`);
+                }
+            }
+            return newSuffixText.join('\n');
+        }
+        // Calculate time until next 5-second interval since startTime
+        const msUntilNextInterval = Math.max(0, 5000 - ((Date.now() - startTime) % 5000));
+        // Do first check immediately
+        const initialCheck = yield checkDeployment();
+        if (initialCheck) {
+            spinner.succeed(chalk_1.default.green('All translations are live!'));
+            return true;
+        }
+        return new Promise((resolve) => {
+            let intervalCheck;
+            // Start the interval aligned with the original request time
+            setTimeout(() => {
+                intervalCheck = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                    const isDeployed = yield checkDeployment();
+                    const elapsed = Date.now() - startTime;
+                    if (isDeployed || elapsed >= timeoutDuration * 1000) {
+                        process.stdout.write('\n');
+                        clearInterval(intervalCheck);
+                        if (isDeployed) {
+                            spinner.succeed(chalk_1.default.green('All translations are live!'));
+                            resolve(true);
+                        }
+                        else {
+                            spinner.fail(chalk_1.default.red('Timed out waiting for translations'));
+                            resolve(false);
+                        }
+                    }
+                }), 5000);
+            }, msUntilNextInterval);
+        });
+    });
+}

package/dist/api/downloadFile.d.ts

@@ -0,0 +1 @@
+export declare function downloadFile(baseUrl: string, apiKey: string, fileId: string, outputPath: string): Promise<boolean>;

package/dist/api/downloadFile.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = downloadFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Helper function to download a file
+function downloadFile(baseUrl, apiKey, fileId, outputPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const downloadResponse = yield fetch(`${baseUrl}/v1/project/translations/files/${fileId}/download`, {
+                method: 'GET',
+                headers: Object.assign({}, (apiKey && { 'x-gt-api-key': apiKey })),
+            });
+            if (downloadResponse.ok) {
+                // Ensure the directory exists
+                const dir = path.dirname(outputPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                // Get the file data as an ArrayBuffer
+                const fileData = yield downloadResponse.arrayBuffer();
+                // Write the file to disk
+                fs.writeFileSync(outputPath, Buffer.from(fileData));
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.error('Error downloading file:', error);
+            return false;
+        }
+    });
+}

package/dist/api/sendFiles.d.ts

@@ -0,0 +1,22 @@
+import { Settings } from '../types';
+import { FileFormats } from '../types/data';
+export interface FileToTranslate {
+    content: string;
+    fileName: string;
+    fileFormat: FileFormats;
+}
+type ApiOptions = Settings & {
+    publish: boolean;
+    wait: boolean;
+};
+/**
+ * Sends multiple files for translation to the API
+ * @param files - Array of file objects to translate
+ * @param options - The options for the API call
+ * @returns The translated content or version ID
+ */
+export declare function sendFiles(files: FileToTranslate[], options: ApiOptions): Promise<{
+    data: any;
+    locales: any;
+}>;
+export {};

package/dist/api/sendFiles.js

@@ -0,0 +1,69 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendFiles = sendFiles;
+const chalk_1 = __importDefault(require("chalk"));
+const console_1 = require("../console/console");
+/**
+ * Sends multiple files for translation to the API
+ * @param files - Array of file objects to translate
+ * @param options - The options for the API call
+ * @returns The translated content or version ID
+ */
+function sendFiles(files, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { apiKey } = options;
+        console.log(chalk_1.default.cyan('\nFiles to translate:'));
+        console.log(files.map((file) => `  - ${chalk_1.default.bold(file.fileName)}`).join('\n'));
+        console.log();
+        const spinner = yield (0, console_1.displayLoadingAnimation)(`Sending ${files.length} file${files.length > 1 ? 's' : ''} to Translation API...`);
+        try {
+            // Create form data
+            const formData = new FormData();
+            // Add each file to the form data
+            files.forEach((file, index) => {
+                formData.append(`file${index}`, new Blob([file.content]), file.fileName);
+                formData.append(`fileFormat${index}`, file.fileFormat);
+                formData.append(`fileName${index}`, file.fileName);
+            });
+            // Add number of files
+            formData.append('fileCount', String(files.length));
+            // Add other metadata
+            formData.append('sourceLocale', options.defaultLocale);
+            formData.append('targetLocales', JSON.stringify(options.locales));
+            formData.append('projectId', options.projectId);
+            formData.append('publish', String(options.publish));
+            formData.append('versionId', options.versionId || '');
+            const response = yield fetch(`${options.baseUrl}/v1/project/translations/files/upload`, {
+                method: 'POST',
+                headers: Object.assign({}, (apiKey && { 'x-gt-api-key': apiKey })),
+                body: formData,
+            });
+            process.stdout.write('\n\n');
+            if (!response.ok) {
+                spinner.fail(yield response.text());
+                process.exit(1);
+            }
+            const responseData = yield response.json();
+            // Handle version ID response (for async processing)
+            const { data, message, locales } = responseData;
+            spinner.succeed(chalk_1.default.green(message || 'Translation job submitted successfully'));
+            return { data, locales };
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red('Failed to send files for translation'));
+            throw error;
+        }
+    });
+}

package/dist/api/sendUpdates.js

@@ -60,7 +60,7 @@ function sendUpdates(updates, options) {
             if (options.wait && locales) {
                 // timeout was validated earlier
                 const timeout = parseInt(options.timeout) * 1000;
-                const result = yield (0, waitForUpdates_1.waitForUpdates)(apiKey, options.baseUrl, versionId, locales, startTime, timeout);
+                yield (0, waitForUpdates_1.waitForUpdates)(apiKey, options.baseUrl, versionId, locales, startTime, timeout);
             }
             return { versionId };
         }

package/dist/cli/base.d.ts

@@ -1,4 +1,4 @@
-import { SupportedLibraries } from '../types';
+import { Settings, SupportedLibraries } from '../types';
 export declare class BaseCLI {
     private library;
     private additionalModules;
@@ -6,5 +6,6 @@ export declare class BaseCLI {
     init(): void;
     execute(): void;
     protected setupGTCommand(): void;
+    protected handleGenericTranslate(settings: Settings): Promise<void>;
     protected setupInitCommand(): void;
 }

package/dist/cli/base.js

@@ -55,12 +55,12 @@ const generaltranslation_1 = require("generaltranslation");
 const findFilepath_1 = __importStar(require("../fs/findFilepath"));
 const errors_1 = require("../console/errors");
 const path_1 = __importDefault(require("path"));
-const yaml_1 = __importDefault(require("yaml"));
 const translate_1 = require("../formats/json/translate");
 const utils_1 = require("../fs/utils");
 const generateSettings_1 = require("../config/generateSettings");
 const chalk_1 = __importDefault(require("chalk"));
 const internal_1 = require("generaltranslation/internal");
+const translate_2 = require("../formats/files/translate");
 const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
 class BaseCLI {
     // Constructor is shared amongst all CLI class types
@@ -86,11 +86,16 @@ class BaseCLI {
             .option('--project-id <id>', 'Project ID for the translation service', (0, utils_1.resolveProjectId)())
             .option('--default-language, --default-locale <locale>', 'Default locale (e.g., en)')
             .option('--new, --locales <locales...>', 'Space-separated list of locales (e.g., en fr es)')
-            .option('-t, --translations-dir, --translation-dir <path>', 'Directory containing your language files. Should be in the format path/to/translations/*.json or path/to/translations/*.yaml')
             .action((options) => __awaiter(this, void 0, void 0, function* () {
             (0, console_1.displayAsciiTitle)();
             (0, console_2.displayInitializingText)();
             const settings = (0, generateSettings_1.generateSettings)(options);
+            yield this.handleGenericTranslate(settings);
+        }));
+    }
+    handleGenericTranslate(settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Validate required settings are present
             if (!settings.locales) {
                 console.error(errors_1.noLocalesError);
                 process.exit(1);
@@ -99,8 +104,8 @@ class BaseCLI {
                 console.error(errors_1.noDefaultLocaleError);
                 process.exit(1);
             }
-            if (!settings.translationsDir) {
-                console.error(errors_1.noTranslationsDirError);
+            if (!settings.files) {
+                console.error(errors_1.noFilesError);
                 process.exit(1);
             }
             if (!settings.apiKey) {
@@ -111,17 +116,7 @@ class BaseCLI {
                 console.error(errors_1.noProjectIdError);
                 process.exit(1);
             }
-            // ---- CREATING UPDATES ---- //
-            // Find the source file in the translationsDir
-            const rawSource = (0, findFilepath_1.findFile)(settings.translationsDir, settings.defaultLocale);
-            if (!rawSource) {
-                console.error(errors_1.noSourceFileError);
-                process.exit(1);
-            }
-            // Get the data format from the ending of the translationsDir
-            const fileExtension = settings.translationsDir
-                .split('.')
-                .pop();
+            // dataFormat for JSONs
             let dataFormat;
             if (this.library === 'next-intl') {
                 dataFormat = 'ICU';
@@ -137,19 +132,38 @@ class BaseCLI {
             else {
                 dataFormat = 'JSX';
             }
-            if (!dataFormat) {
-                console.error(errors_1.noDataFormatError);
-                process.exit(1);
+            const { resolvedPaths: sourceFiles, placeholderPaths } = settings.files;
+            // ---- CREATING UPDATES ---- //
+            if (sourceFiles.json) {
+                // Only translate JSON files if not using gt-react or gt-next
+                // ReactCLI will handle the JSON files differently
+                if (this.library !== 'gt-react' && this.library !== 'gt-next') {
+                    const rawSource = (0, findFilepath_1.readFile)(sourceFiles.json[0]);
+                    if (!rawSource) {
+                        console.error(errors_1.noSourceFileError);
+                        process.exit(1);
+                    }
+                    if (!dataFormat) {
+                        console.error(errors_1.noDataFormatError);
+                        process.exit(1);
+                    }
+                    else if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
+                        console.error(errors_1.noSupportedDataFormatError);
+                        process.exit(1);
+                    }
+                    const source = JSON.parse(rawSource);
+                    yield (0, translate_1.translateJson)(source, settings, dataFormat, placeholderPaths);
+                }
             }
-            else if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
-                console.error(errors_1.noSupportedDataFormatError);
-                process.exit(1);
+            if (sourceFiles.mdx || sourceFiles.md) {
+                if (sourceFiles.mdx) {
+                    yield (0, translate_2.translateFiles)(sourceFiles, placeholderPaths, 'MDX', settings);
+                }
+                if (sourceFiles.md) {
+                    yield (0, translate_2.translateFiles)(sourceFiles, placeholderPaths, 'MD', settings);
+                }
             }
-            const source = fileExtension === 'json'
-                ? JSON.parse(rawSource)
-                : yaml_1.default.parse(rawSource);
-            const result = yield (0, translate_1.translateJson)(source, settings, dataFormat, fileExtension);
-        }));
+        });
     }
     setupInitCommand() {
         commander_1.program
@@ -181,14 +195,14 @@ class BaseCLI {
             });
             // Ask where the translations are stored
             const location = yield (0, prompts_1.select)({
-                message: 'Where are your language files stored? (CDN or local)',
+                message: `Where are your language files stored? ${chalk_1.default.gray('(remote or local)')}`,
                 choices: [
-                    { value: 'cdn', name: 'CDN' },
+                    { value: 'remote', name: 'Remote' },
                     { value: 'local', name: 'Local' },
                 ],
-                default: 'cdn',
+                default: 'remote',
             });
-            if (location === 'cdn') {
+            if (location === 'remote') {
                 // Create gt.config.json
                 (0, setupConfig_1.default)('gt.config.json', {
                     defaultLocale,
@@ -204,7 +218,7 @@ class BaseCLI {
             // Ask if using another i18n library
             const i18nLibrary = thirdPartyLibrary
                 ? yield (0, prompts_1.select)({
-                    message: `Are you using a third-party i18n library? (${chalk_1.default.gray(`Auto-detected: ${this.library}`)})`,
+                    message: `Are you using a 3rd-party i18n library? ${chalk_1.default.gray(`(Auto-detected: ${this.library === 'base' ? 'none' : this.library})`)}`,
                     choices: [
                         { value: true, name: 'Yes' },
                         { value: false, name: 'No' },
@@ -215,25 +229,34 @@ class BaseCLI {
             if (i18nLibrary) {
                 const dataFormat = yield (0, prompts_1.select)({
                     message: 'What is the format of your language files?',
-                    choices: ['.json', '.yaml'],
-                    default: '.json',
+                    choices: ['json'],
+                    default: 'json',
                 });
                 // combine translationsDir and dataFormat into something like
-                // translationsDir/*[.json|.yaml]
-                const translationsDirWithFormat = path_1.default.join(translationsDir, `*${dataFormat}`);
+                // translationsDir/[locale].json
+                const translationsDirWithFormat = path_1.default.join(translationsDir, `[locale].${dataFormat}`);
                 // Create gt.config.json
                 (0, setupConfig_1.default)('gt.config.json', {
                     defaultLocale,
                     locales: locales.split(' '),
-                    translationsDir: translationsDirWithFormat,
+                    files: {
+                        json: {
+                            include: [translationsDirWithFormat],
+                        },
+                    },
                 });
             }
             else {
+                const translationsDirWithFormat = path_1.default.join(translationsDir, `[locale].json`);
                 // Create gt.config.json
                 (0, setupConfig_1.default)('gt.config.json', {
                     defaultLocale,
                     locales: locales.split(' '),
-                    translationsDir: translationsDir,
+                    files: {
+                        json: {
+                            include: [translationsDirWithFormat],
+                        },
+                    },
                 });
             }
         }));

package/dist/cli/next.d.ts

@@ -9,9 +9,6 @@ export declare class NextCLI extends ReactCLI {
         filesUpdated: string[];
         warnings: string[];
     }>;
-    protected createDictionaryUpdates(options: Options & {
-        dictionary: string;
-    }, esbuildConfig: any): Promise<Updates>;
     protected createInlineUpdates(options: Options): Promise<{
         updates: Updates;
         errors: string[];

package/dist/cli/next.js

@@ -19,7 +19,6 @@ const prompts_1 = require("@inquirer/prompts");
 const postProcess_1 = require("../hooks/postProcess");
 const findFilepath_1 = __importDefault(require("../fs/findFilepath"));
 const scanForContent_1 = __importDefault(require("../next/parse/scanForContent"));
-const createDictionaryUpdates_1 = __importDefault(require("../react/parse/createDictionaryUpdates"));
 const createInlineUpdates_1 = __importDefault(require("../react/parse/createInlineUpdates"));
 const handleInitGT_1 = __importDefault(require("../next/parse/handleInitGT"));
 const react_1 = require("./react");
@@ -41,9 +40,6 @@ class NextCLI extends react_1.ReactCLI {
     scanForContent(options, framework) {
         return (0, scanForContent_1.default)(options, pkg, framework);
     }
-    createDictionaryUpdates(options, esbuildConfig) {
-        return (0, createDictionaryUpdates_1.default)(options, esbuildConfig);
-    }
     createInlineUpdates(options) {
         return (0, createInlineUpdates_1.default)(options, pkg);
     }

package/dist/cli/react.d.ts

@@ -9,9 +9,7 @@ export declare class ReactCLI extends BaseCLI {
         filesUpdated: string[];
         warnings: string[];
     }>;
-    protected createDictionaryUpdates(options: Options & {
-        dictionary: string;
-    }, esbuildConfig: any): Promise<Updates>;
+    protected createDictionaryUpdates(options: Options, dictionaryPath: string, esbuildConfig?: any): Promise<Updates>;
     protected createInlineUpdates(options: Options): Promise<{
         updates: Updates;
         errors: string[];
@@ -20,11 +18,11 @@ export declare class ReactCLI extends BaseCLI {
     protected setupGenerateSourceCommand(): void;
     protected setupSetupCommand(): void;
     protected setupScanCommand(): void;
-    protected handleGenerateSourceCommand(options: GenerateSourceOptions): Promise<void>;
+    protected handleGenerateSourceCommand(initOptions: GenerateSourceOptions): Promise<void>;
     protected handleScanCommand(options: WrapOptions): Promise<void>;
     protected handleSetupCommand(options: SetupOptions): Promise<void>;
     protected handleTranslateCommand(initOptions: Options): Promise<void>;
-    protected createUpdates(options: Options | GenerateSourceOptions): Promise<{
+    protected createUpdates(options: Options | GenerateSourceOptions, sourceDictionary: string | undefined): Promise<{
         updates: Updates;
         errors: string[];
     }>;