gtx-cli 0.0.2 → 1.0.0-alpha.2

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/{fs/saveTranslations.js → api/fetchTranslations.js}

@@ -12,12 +12,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = saveTranslations;
-exports.saveSourceFile = saveSourceFile;
+exports.fetchTranslations = fetchTranslations;
 const chalk_1 = __importDefault(require("chalk"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-function saveTranslations(baseUrl, apiKey, versionId, translationsDir) {
+/**
+ * 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)}`, {
@@ -27,31 +32,11 @@ function saveTranslations(baseUrl, apiKey, versionId, translationsDir) {
         if (response.ok) {
             const data = yield response.json();
             const translations = data.translations;
-            for (const translation of translations) {
-                const locale = translation.locale;
-                const translationData = translation.translation;
-                const filepath = path_1.default.join(translationsDir, `${locale}.json`);
-                // Ensure directory exists
-                fs_1.default.mkdirSync(path_1.default.dirname(filepath), { recursive: true });
-                fs_1.default.writeFileSync(filepath, JSON.stringify(translationData, null, 2));
-            }
-            console.log(chalk_1.default.green('Translations saved successfully!'));
+            return translations;
         }
         else {
             console.error(chalk_1.default.red('Failed to fetch translations'));
         }
+        return [];
     });
 }
-function saveSourceFile(filepath, data) {
-    // Ensure directory exists
-    fs_1.default.mkdirSync(path_1.default.dirname(filepath), { recursive: true });
-    // Convert updates to the proper data format
-    const obj = {};
-    for (const update of data) {
-        const { source, metadata } = update;
-        const { hash } = metadata;
-        obj[hash] = source;
-    }
-    fs_1.default.writeFileSync(filepath, JSON.stringify(obj, null, 2));
-    console.log(chalk_1.default.green('Source file saved successfully!'));
-}

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

@@ -1 +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

@@ -16,6 +16,16 @@ 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 = [];

package/dist/cli/base.d.ts

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

package/dist/cli/base.js

@@ -1,11 +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;
-// packages/gt-cli-core/src/BaseCLI.ts
 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() {
+    // 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

@@ -1,7 +1,9 @@
-import { WrapOptions, Options, Updates, SetupOptions, SupportedFrameworks } from 'gt-react-cli/types';
+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[];

package/dist/cli/next.js

@@ -13,26 +13,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextCLI = void 0;
-const console_1 = require("gt-react-cli/console/console");
+const console_1 = require("../console/console");
 const chalk_1 = __importDefault(require("chalk"));
 const prompts_1 = require("@inquirer/prompts");
-const setupConfig_1 = __importDefault(require("gt-react-cli/fs/config/setupConfig"));
-const postProcess_1 = require("gt-react-cli/hooks/postProcess");
-const findFilepath_1 = __importDefault(require("gt-react-cli/fs/findFilepath"));
+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("gt-react-cli/updates/createDictionaryUpdates"));
-const createInlineUpdates_1 = __importDefault(require("gt-react-cli/updates/createInlineUpdates"));
+const createDictionaryUpdates_1 = __importDefault(require("../react/updates/createDictionaryUpdates"));
+const createInlineUpdates_1 = __importDefault(require("../react/updates/createInlineUpdates"));
 const handleInitGT_1 = __importDefault(require("../next/parse/handleInitGT"));
 const react_1 = require("./react");
+const generateSettings_1 = require("../config/generateSettings");
 const pkg = 'gt-next';
 class NextCLI extends react_1.ReactCLI {
     constructor() {
         super();
+    }
+    init() {
         this.setupTranslateCommand();
         this.setupSetupCommand();
         this.setupScanCommand();
         this.setupGenerateSourceCommand();
     }
+    execute() {
+        super.execute();
+    }
     scanForContent(options, framework) {
         return (0, scanForContent_1.default)(options, pkg, framework);
     }
@@ -109,8 +114,7 @@ class NextCLI extends react_1.ReactCLI {
                 default: true,
             });
             // ----- Create a starter gt.config.json file -----
-            if (!options.config)
-                (0, setupConfig_1.default)('gt.config.json', process.env.GT_PROJECT_ID, '');
+            (0, generateSettings_1.generateSettings)(options);
             // ----- //
             const mergeOptions = Object.assign(Object.assign({}, options), { disableIds: !includeTId, disableFormatting: true, addGTProvider });
             // Wrap all JSX elements in the src directory with a <T> tag, with unique ids

package/dist/cli/react.d.ts

@@ -2,6 +2,8 @@ import { Options, SetupOptions, SupportedFrameworks, Updates, WrapOptions, Gener
 import { BaseCLI } from './base';
 export declare class ReactCLI extends BaseCLI {
     constructor();
+    init(): void;
+    execute(): void;
     protected scanForContent(options: WrapOptions, framework: SupportedFrameworks): Promise<{
         errors: string[];
         filesUpdated: string[];