gtx-cli 0.0.1 → 0.0.2

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/waitForUpdates.d.ts

@@ -0,0 +1 @@
+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,89 @@
+"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");
+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,3 @@
+export declare class BaseCLI {
+    constructor();
+}

package/dist/cli/base.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCLI = void 0;
+// packages/gt-cli-core/src/BaseCLI.ts
+const commander_1 = require("commander");
+class BaseCLI {
+    constructor() {
+        commander_1.program.parse();
+    }
+}
+exports.BaseCLI = BaseCLI;

package/dist/cli/next.d.ts

@@ -0,0 +1,18 @@
+import { WrapOptions, Options, Updates, SetupOptions, SupportedFrameworks } from 'gt-react-cli/types';
+import { ReactCLI } from './react';
+export declare class NextCLI extends ReactCLI {
+    constructor();
+    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>;
+}

package/dist/cli/next.js

@@ -0,0 +1,162 @@
+"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.NextCLI = void 0;
+const console_1 = require("gt-react-cli/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 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 handleInitGT_1 = __importDefault(require("../next/parse/handleInitGT"));
+const react_1 = require("./react");
+const pkg = 'gt-next';
+class NextCLI extends react_1.ReactCLI {
+    constructor() {
+        super();
+        this.setupTranslateCommand();
+        this.setupSetupCommand();
+        this.setupScanCommand();
+        this.setupGenerateSourceCommand();
+    }
+    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);
+    }
+    handleSetupCommand(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, console_1.displayAsciiTitle)();
+            (0, console_1.displayInitializingText)();
+            // Ask user for confirmation using inquirer
+            const answer = yield (0, prompts_1.select)({
+                message: chalk_1.default.yellow(`This operation will prepare your project for internationalization.
+        Make sure you have committed or stashed any changes.
+        Do you want to continue?`),
+                choices: [
+                    { value: true, name: 'Yes' },
+                    { value: false, name: 'No' },
+                ],
+                default: true,
+            });
+            if (!answer) {
+                console.log(chalk_1.default.gray('\nOperation cancelled.'));
+                process.exit(0);
+            }
+            const routerType = yield (0, prompts_1.select)({
+                message: 'Are you using the Next.js App router or the Pages router?',
+                choices: [
+                    { value: 'app', name: 'App Router' },
+                    { value: 'pages', name: 'Pages Router' },
+                ],
+                default: 'app',
+            });
+            if (routerType === 'pages') {
+                console.log(chalk_1.default.red('\nPlease use gt-react and gt-react-cli instead. gt-next is currently not supported for the Pages router.'));
+                process.exit(0);
+            }
+            const addGTProvider = yield (0, prompts_1.select)({
+                message: 'Do you want the setup tool to automatically add the GTProvider component?',
+                choices: [
+                    { value: true, name: 'Yes' },
+                    { value: false, name: 'No' },
+                ],
+                default: true,
+            });
+            // Check if they have a next.config.js file
+            const nextConfigPath = (0, findFilepath_1.default)([
+                './next.config.js',
+                './next.config.ts',
+                './next.config.mjs',
+                './next.config.mts',
+            ]);
+            if (!nextConfigPath) {
+                console.log(chalk_1.default.red('No next.config.js file found.'));
+                process.exit(0);
+            }
+            const addWithGTConfig = yield (0, prompts_1.select)({
+                message: `Do you want to automatically add withGTConfig() to your ${nextConfigPath}?`,
+                choices: [
+                    { value: true, name: 'Yes' },
+                    { value: false, name: 'No' },
+                ],
+                default: true,
+            });
+            const includeTId = yield (0, prompts_1.select)({
+                message: 'Do you want to include an unique id for each <T> tag?',
+                choices: [
+                    { value: true, name: 'Yes' },
+                    { value: false, name: 'No' },
+                ],
+                default: true,
+            });
+            // ----- Create a starter gt.config.json file -----
+            if (!options.config)
+                (0, setupConfig_1.default)('gt.config.json', process.env.GT_PROJECT_ID, '');
+            // ----- //
+            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
+            const { errors, filesUpdated, warnings } = yield this.scanForContent(mergeOptions, 'next-app');
+            if (addWithGTConfig) {
+                // Add the withGTConfig() function to the next.config.js file
+                const { errors: initGTErrors, filesUpdated: initGTFilesUpdated } = yield (0, handleInitGT_1.default)(nextConfigPath);
+                // merge errors and files
+                errors.push(...initGTErrors);
+                filesUpdated.push(...initGTFilesUpdated);
+            }
+            if (errors.length > 0) {
+                console.log(chalk_1.default.red('\n✗ Failed to write files:\n'));
+                console.log(errors.join('\n'));
+            }
+            console.log(chalk_1.default.green(`\nSuccess! Added <T> tags and updated ${chalk_1.default.bold(filesUpdated.length)} files:\n`));
+            if (filesUpdated.length > 0) {
+                console.log(filesUpdated.map((file) => `${chalk_1.default.green('-')} ${file}`).join('\n'));
+                console.log();
+                console.log(chalk_1.default.green('Please verify the changes before committing.'));
+            }
+            if (warnings.length > 0) {
+                console.log(chalk_1.default.yellow('\nWarnings encountered:'));
+                console.log(warnings.map((warning) => `${chalk_1.default.yellow('-')} ${warning}`).join('\n'));
+            }
+            // Stage only the modified files
+            // const { execSync } = require('child_process');
+            // for (const file of filesUpdated) {
+            //   await execSync(`git add "${file}"`);
+            // }
+            const formatter = yield (0, postProcess_1.detectFormatter)();
+            if (!formatter || filesUpdated.length === 0) {
+                return;
+            }
+            const applyFormatting = yield (0, prompts_1.select)({
+                message: `Would you like to auto-format the modified files? ${chalk_1.default.gray(`(${formatter})`)}`,
+                choices: [
+                    { value: true, name: 'Yes' },
+                    { value: false, name: 'No' },
+                ],
+                default: true,
+            });
+            // Format updated files if formatters are available
+            if (applyFormatting)
+                yield (0, postProcess_1.formatFiles)(filesUpdated, formatter);
+        });
+    }
+}
+exports.NextCLI = NextCLI;

package/dist/cli/react.d.ts

@@ -0,0 +1,29 @@
+import { Options, SetupOptions, SupportedFrameworks, Updates, WrapOptions, GenerateSourceOptions } from '../types';
+import { BaseCLI } from './base';
+export declare class ReactCLI extends BaseCLI {
+    constructor();
+    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 setupTranslateCommand(): void;
+    protected setupGenerateSourceCommand(): void;
+    protected setupSetupCommand(): void;
+    protected setupScanCommand(): void;
+    protected handleGenerateSourceCommand(options: 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<{
+        updates: Updates;
+        errors: string[];
+    }>;
+}