gtx-cli 0.0.1 → 1.0.0-alpha.1

package/README.md

@@ -4,25 +4,22 @@
   </a>
 </p>
 
-# gt-react-cli: Command-line tool for gt-react
+# gtx-cli: General Purpose CLI Tool for General Translation
 
-gt-react-cli is a command-line tool used to push `gt-react` dictionaries and `<T>` components to be translated.
-
-Additionally, it can scan your project for all content that needs to be translated, and automatically wrap them in `<T>` and `<Var>` components.
+gtx-cli is a command-line tool used to interface with General Translation's AI-powered i18n platform.
 
 See our [docs](https://generaltranslation.com/docs) for more information including guides, examples, and API references.
 
 ## Installation
 
 ```bash
-npm install gt-react-cli
+npm install gtx-cli
 ```
 
 ## Usage
 
 ```bash
-npx gt-react-cli translate
-npx gt-react-cli setup
+npx gtx-cli translate
 ```
 
 ## Documentation

package/dist/api/fetchTranslations.d.ts

@@ -0,0 +1,10 @@
+import { RetrievedTranslations } from '../types/api';
+/**
+ * Fetches translations from the API and saves them to a local directory
+ * @param baseUrl - The base URL for the API
+ * @param apiKey - The API key for the API
+ * @param versionId - The version ID of the project
+ * @param translationsDir - The directory to save the translations to
+ * @param fileType - The file type to save the translations as (file extension)
+ */
+export declare function fetchTranslations(baseUrl: string, apiKey: string, versionId: string): Promise<RetrievedTranslations>;

package/dist/api/fetchTranslations.js

@@ -0,0 +1,42 @@
+"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.fetchTranslations = fetchTranslations;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Fetches translations from the API and saves them to a local directory
+ * @param baseUrl - The base URL for the API
+ * @param apiKey - The API key for the API
+ * @param versionId - The version ID of the project
+ * @param translationsDir - The directory to save the translations to
+ * @param fileType - The file type to save the translations as (file extension)
+ */
+function fetchTranslations(baseUrl, apiKey, versionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // First fetch the translations from the API
+        const response = yield fetch(`${baseUrl}/v1/project/translations/info/${encodeURIComponent(versionId)}`, {
+            method: 'GET',
+            headers: Object.assign({ 'Content-Type': 'application/json' }, (apiKey && { 'x-gt-api-key': apiKey })),
+        });
+        if (response.ok) {
+            const data = yield response.json();
+            const translations = data.translations;
+            return translations;
+        }
+        else {
+            console.error(chalk_1.default.red('Failed to fetch translations'));
+        }
+        return [];
+    });
+}

package/dist/api/sendUpdates.d.ts

@@ -0,0 +1,18 @@
+import { Settings, Updates } from '../types';
+import { DataFormat } from '../types/data';
+type ApiOptions = Settings & {
+    publish: boolean;
+    wait: boolean;
+    timeout: string;
+    dataFormat: DataFormat;
+};
+/**
+ * Sends updates to the API
+ * @param updates - The updates to send
+ * @param options - The options for the API call
+ * @returns The versionId of the updated project
+ */
+export declare function sendUpdates(updates: Updates, options: ApiOptions): Promise<{
+    versionId: any;
+} | undefined>;
+export {};

package/dist/api/sendUpdates.js

@@ -0,0 +1,72 @@
+"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.sendUpdates = sendUpdates;
+const chalk_1 = __importDefault(require("chalk"));
+const console_1 = require("../console/console");
+const updateConfig_1 = __importDefault(require("../fs/config/updateConfig"));
+const waitForUpdates_1 = require("./waitForUpdates");
+/**
+ * Sends updates to the API
+ * @param updates - The updates to send
+ * @param options - The options for the API call
+ * @returns The versionId of the updated project
+ */
+function sendUpdates(updates, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { apiKey, projectId, defaultLocale, dataFormat } = options;
+        const globalMetadata = Object.assign(Object.assign({}, (projectId && { projectId })), (defaultLocale && { sourceLocale: defaultLocale }));
+        // If additionalLocales is provided, additionalLocales + project.current_locales will be translated
+        // If not, then options.locales will be translated
+        // If neither, then project.current_locales will be translated
+        const body = Object.assign(Object.assign(Object.assign(Object.assign({ updates }, (options.locales && { locales: options.locales })), { metadata: globalMetadata, publish: options.publish }), (dataFormat && { dataFormat })), (options.versionId && { versionId: options.versionId }));
+        const spinner = yield (0, console_1.displayLoadingAnimation)('Sending updates to General Translation API...');
+        try {
+            const startTime = Date.now();
+            const response = yield fetch(`${options.baseUrl}/v1/project/translations/update`, {
+                method: 'POST',
+                headers: Object.assign({ 'Content-Type': 'application/json' }, (apiKey && { 'x-gt-api-key': apiKey })),
+                body: JSON.stringify(body),
+            });
+            process.stdout.write('\n\n');
+            if (!response.ok) {
+                spinner.fail(yield response.text());
+                process.exit(1);
+            }
+            if (response.status === 204) {
+                spinner.succeed(yield response.text());
+                return;
+            }
+            const { versionId, message, locales } = yield response.json();
+            spinner.succeed(chalk_1.default.green(message));
+            if (options.config)
+                (0, updateConfig_1.default)({
+                    configFilepath: options.config,
+                    _versionId: versionId,
+                    locales,
+                });
+            // Wait for translations if wait is true
+            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);
+            }
+            return { versionId };
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red('Failed to send updates'));
+            throw error;
+        }
+    });
+}

package/dist/api/waitForUpdates.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Waits for translations to be deployed to the General Translation API
+ * @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
+ * @returns True if all translations are deployed, false otherwise
+ */
+export declare const waitForUpdates: (apiKey: string, baseUrl: string, versionId: string, locales: string[], startTime: number, timeoutDuration: number) => Promise<boolean>;

package/dist/api/waitForUpdates.js

@@ -0,0 +1,99 @@
+"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.waitForUpdates = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const console_1 = require("../console/console");
+const generaltranslation_1 = require("generaltranslation");
+/**
+ * Waits for translations to be deployed to the General Translation API
+ * @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
+ * @returns True if all translations are deployed, false otherwise
+ */
+const waitForUpdates = (apiKey, baseUrl, versionId, locales, startTime, timeoutDuration) => __awaiter(void 0, void 0, void 0, function* () {
+    const spinner = yield (0, console_1.displayLoadingAnimation)('Waiting for translation...');
+    const availableLocales = [];
+    const checkDeployment = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const response = yield fetch(`${baseUrl}/v1/project/translations/status/${encodeURIComponent(versionId)}`, {
+                method: 'GET',
+                headers: Object.assign({ 'Content-Type': 'application/json' }, (apiKey && { 'x-gt-api-key': apiKey })),
+            });
+            if (response.ok) {
+                const data = yield response.json();
+                if (data.availableLocales) {
+                    data.availableLocales.forEach((locale) => {
+                        if (!availableLocales.includes(locale) &&
+                            locales.includes(locale)) {
+                            availableLocales.push(locale);
+                        }
+                    });
+                    const newSuffixText = [
+                        `\n\n` +
+                            chalk_1.default.green(`${availableLocales.length}/${locales.length}`) +
+                            ` translations completed`,
+                        ...availableLocales.map((locale) => {
+                            const localeProperties = (0, generaltranslation_1.getLocaleProperties)(locale);
+                            return `Translation completed for ${chalk_1.default.green(localeProperties.name)} (${chalk_1.default.green(localeProperties.code)})`;
+                        }),
+                    ];
+                    spinner.suffixText = newSuffixText.join('\n');
+                }
+                if (locales.every((locale) => availableLocales.includes(locale))) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        catch (error) {
+            return false;
+        }
+    });
+    // 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(void 0, void 0, void 0, function* () {
+                const isDeployed = yield checkDeployment();
+                const elapsed = Date.now() - startTime;
+                if (isDeployed || elapsed >= timeoutDuration) {
+                    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);
+    });
+});
+exports.waitForUpdates = waitForUpdates;

package/dist/cli/base.d.ts

@@ -0,0 +1,9 @@
+import { SupportedLibraries } from '../types';
+export declare class BaseCLI {
+    private library;
+    constructor(library: SupportedLibraries);
+    init(): void;
+    execute(): void;
+    protected setupGTCommand(): void;
+    protected setupInitCommand(): void;
+}

package/dist/cli/base.js

@@ -0,0 +1,191 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCLI = void 0;
+const commander_1 = require("commander");
+const console_1 = require("../console/console");
+const console_2 = require("../console/console");
+const setupConfig_1 = __importDefault(require("../fs/config/setupConfig"));
+const prompts_1 = require("@inquirer/prompts");
+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 SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
+class BaseCLI {
+    // Constructor is shared amongst all CLI class types
+    constructor(library) {
+        this.library = library;
+        this.setupInitCommand();
+    }
+    // Init is never called in a child class
+    init() {
+        this.setupGTCommand();
+    }
+    // Execute is called by the main program
+    execute() {
+        commander_1.program.parse();
+    }
+    setupGTCommand() {
+        commander_1.program
+            .command('translate')
+            .description('Translate your project using General Translation')
+            .option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', (0, findFilepath_1.default)(['gt.config.json']))
+            .option('--api-key <key>', 'API key for General Translation cloud service')
+            .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);
+            if (!settings.locales) {
+                console.error(errors_1.noLocalesError);
+                process.exit(1);
+            }
+            if (!settings.defaultLocale) {
+                console.error(errors_1.noDefaultLocaleError);
+                process.exit(1);
+            }
+            if (!settings.translationsDir) {
+                console.error(errors_1.noTranslationsDirError);
+                process.exit(1);
+            }
+            if (!settings.apiKey) {
+                console.error(errors_1.noApiKeyError);
+                process.exit(1);
+            }
+            if (!settings.projectId) {
+                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();
+            const dataFormat = this.library === 'next-intl'
+                ? 'ICU'
+                : this.library === 'react-i18next'
+                    ? 'I18NEXT'
+                    : this.library === 'next-i18next'
+                        ? 'I18NEXT'
+                        : 'JSX';
+            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 = 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
+            .command('init')
+            .description('Initialize project for General Translation')
+            .action(() => __awaiter(this, void 0, void 0, function* () {
+            (0, console_1.displayAsciiTitle)();
+            (0, console_2.displayInitializingText)();
+            // Ask where the translations are stored
+            const translationsDir = yield (0, prompts_1.input)({
+                message: 'Where is the directory containing your language files?',
+            });
+            // Ask for the default locale
+            const defaultLocale = yield (0, prompts_1.input)({
+                message: 'What is the default locale for your project?',
+            });
+            // Ask for the locales
+            const locales = yield (0, prompts_1.input)({
+                message: 'What locales would you like to translate using General Translation? (space-separated list)',
+                validate: (input) => {
+                    const locales = input.split(' ');
+                    if (locales.length === 0) {
+                        return 'Please enter at least one locale';
+                    }
+                    for (const locale of locales) {
+                        if (!(0, generaltranslation_1.isValidLocale)(locale)) {
+                            return 'Please enter a valid locale (e.g., en, fr, es)';
+                        }
+                    }
+                    return true;
+                },
+            });
+            const dataFormat = yield (0, prompts_1.select)({
+                message: 'What is the format of your language files?',
+                choices: ['.json', '.yaml'],
+                default: '.json',
+            });
+            // combine translationsDir and dataFormat into something like
+            // translationsDir/*[.json|.yaml]
+            const translationsDirWithFormat = path_1.default.join(translationsDir, `*${dataFormat}`);
+            // Create gt.config.json
+            (0, setupConfig_1.default)('gt.config.json', {
+                defaultLocale,
+                locales: locales.split(' '),
+                translationsDir: translationsDirWithFormat,
+            });
+        }));
+    }
+}
+exports.BaseCLI = BaseCLI;

package/dist/cli/next.d.ts

@@ -0,0 +1,20 @@
+import { WrapOptions, Options, Updates, SetupOptions, SupportedFrameworks } from '../types';
+import { ReactCLI } from './react';
+export declare class NextCLI extends ReactCLI {
+    constructor();
+    init(): void;
+    execute(): void;
+    protected scanForContent(options: WrapOptions, framework: SupportedFrameworks): Promise<{
+        errors: string[];
+        filesUpdated: string[];
+        warnings: string[];
+    }>;
+    protected createDictionaryUpdates(options: Options & {
+        dictionary: string;
+    }, esbuildConfig: any): Promise<Updates>;
+    protected createInlineUpdates(options: Options): Promise<{
+        updates: Updates;
+        errors: string[];
+    }>;
+    protected handleSetupCommand(options: SetupOptions): Promise<void>;
+}