gtx-cli 1.2.15 → 1.2.17

package/dist/translation/stage.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stageProject = stageProject;
+const errors_1 = require("../console/errors");
+const chalk_1 = __importDefault(require("chalk"));
+const findFilepath_1 = __importDefault(require("../fs/findFilepath"));
+const logging_1 = require("../console/logging");
+const parse_1 = require("./parse");
+const errors_2 = require("../console/errors");
+const sendUpdates_1 = require("../api/sendUpdates");
+async function stageProject(settings, pkg) {
+    if (!settings.dictionary) {
+        settings.dictionary = (0, findFilepath_1.default)([
+            './dictionary.js',
+            './src/dictionary.js',
+            './dictionary.json',
+            './src/dictionary.json',
+            './dictionary.ts',
+            './src/dictionary.ts',
+        ]);
+    }
+    // Separate defaultLocale from locales
+    settings.locales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
+    // validate timeout
+    const timeout = parseInt(settings.timeout);
+    if (isNaN(timeout) || timeout < 0) {
+        (0, errors_1.logErrorAndExit)(`Invalid timeout: ${settings.timeout}. Must be a positive integer.`);
+    }
+    settings.timeout = timeout.toString();
+    // ---- CREATING UPDATES ---- //
+    const { updates, errors } = await (0, parse_1.createUpdates)(settings, settings.dictionary, pkg);
+    if (errors.length > 0) {
+        if (settings.ignoreErrors) {
+            (0, logging_1.logWarning)(chalk_1.default.yellow(`Warning: CLI tool encountered syntax errors while scanning for translatable content. These components will not be translated.\n` +
+                errors
+                    .map((error) => chalk_1.default.yellow('• ') + chalk_1.default.white(error) + '\n')
+                    .join('')));
+        }
+        else {
+            (0, errors_1.logErrorAndExit)(chalk_1.default.red(`Error: CLI tool encountered syntax errors while scanning for translatable content. ${chalk_1.default.gray('To ignore these errors, re-run with --ignore-errors')}\n` +
+                errors
+                    .map((error) => chalk_1.default.red('• ') + chalk_1.default.white(error) + '\n')
+                    .join('')));
+        }
+    }
+    if (settings.dryRun) {
+        (0, logging_1.logSuccess)('Dry run: No translations were sent to General Translation.');
+        return null;
+    }
+    if (updates.length == 0) {
+        (0, logging_1.logError)(chalk_1.default.red(`No in-line content or dictionaries were found for ${chalk_1.default.green(pkg)}. Are you sure you're running this command in the right directory?`));
+        return null;
+    }
+    // Send updates to General Translation API
+    if (!settings.locales) {
+        (0, errors_1.logErrorAndExit)(errors_2.noLocalesError);
+    }
+    if (!settings.defaultLocale) {
+        (0, errors_1.logErrorAndExit)(errors_2.noDefaultLocaleError);
+    }
+    if (!settings.apiKey) {
+        (0, errors_1.logErrorAndExit)(errors_2.noApiKeyError);
+    }
+    if (settings.apiKey.startsWith('gtx-dev-')) {
+        (0, errors_1.logErrorAndExit)(errors_1.devApiKeyError);
+    }
+    if (!settings.projectId) {
+        (0, errors_1.logErrorAndExit)(errors_2.noProjectIdError);
+    }
+    const updateResponse = await (0, sendUpdates_1.sendUpdates)(updates, {
+        ...settings,
+        timeout: settings.timeout,
+        dataFormat: 'JSX',
+    }, pkg);
+    const { versionId, locales } = updateResponse;
+    return { versionId, locales };
+}

package/dist/translation/translate.d.ts

@@ -0,0 +1,2 @@
+import { Options, Settings } from '../types';
+export declare function translate(settings: Options & Settings, versionId: string): Promise<void>;

package/dist/translation/translate.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translate = translate;
+const fetchTranslations_1 = require("../api/fetchTranslations");
+const waitForUpdates_1 = require("../api/waitForUpdates");
+const save_1 = require("../formats/gt/save");
+const utils_1 = require("../config/utils");
+async function translate(settings, versionId) {
+    // timeout was validated earlier
+    const startTime = Date.now();
+    const timeout = parseInt(settings.timeout) * 1000;
+    const result = await (0, waitForUpdates_1.waitForUpdates)(settings.apiKey, settings.baseUrl, versionId, startTime, timeout);
+    if (!result) {
+        process.exit(1);
+    }
+    const translations = await (0, fetchTranslations_1.fetchTranslations)(settings.baseUrl, settings.apiKey, versionId);
+    // Save translations to local directory if files.gt.output is provided
+    if (settings.files && (0, utils_1.isUsingLocalTranslations)(settings)) {
+        await (0, save_1.saveTranslations)(translations, settings.files.placeholderPaths, 'JSX');
+    }
+}

package/dist/types/api.d.ts

@@ -0,0 +1,6 @@
+export type RetrievedTranslation = {
+    locale: string;
+    translation: any;
+    metadata: any;
+};
+export type RetrievedTranslations = RetrievedTranslation[];

package/dist/types/api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/data.d.ts

@@ -0,0 +1,31 @@
+export type Entry = string;
+export type DictionaryMetadata = {
+    context?: string;
+    variablesOptions?: Record<string, any>;
+    [key: string]: any;
+};
+export type DictionaryEntry = Entry | [Entry] | [Entry, DictionaryMetadata];
+export type Dictionary = {
+    [key: string]: Dictionary | DictionaryEntry;
+};
+export type FlattenedDictionary = {
+    [key: string]: DictionaryEntry;
+};
+export type JSONDictionary = {
+    [key: string]: string | JSONDictionary;
+};
+export type FlattenedJSONDictionary = {
+    [key: string]: string;
+};
+export type DataFormat = 'JSX' | 'ICU' | 'I18NEXT';
+export type FileFormats = 'JSON' | 'YAML' | 'MDX' | 'MD' | 'TS' | 'JS';
+export type JsxChildren = string | string[] | any;
+export type Translations = {
+    [key: string]: JsxChildren;
+};
+export type TranslationsMetadata = {
+    [key: string]: {
+        id?: string;
+        hash?: string;
+    };
+};

package/dist/types/data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1,101 @@
+import { JsxChildren } from 'generaltranslation/internal';
+import { SUPPORTED_FILE_EXTENSIONS } from '../formats/files/supportedFiles';
+export type Updates = ({
+    metadata: Record<string, any>;
+} & ({
+    dataFormat: 'JSX';
+    source: JsxChildren;
+} | {
+    dataFormat: 'ICU';
+    source: string;
+} | {
+    dataFormat: 'I18NEXT';
+    source: string;
+}))[];
+export type Options = {
+    config: string;
+    apiKey?: string;
+    projectId?: string;
+    versionId?: string;
+    jsconfig?: string;
+    dictionary?: string;
+    src?: string[];
+    defaultLocale?: string;
+    locales?: string[];
+    baseUrl: string;
+    inline?: boolean;
+    ignoreErrors: boolean;
+    dryRun: boolean;
+    timeout: string;
+    stageTranslations?: boolean;
+};
+export type WrapOptions = {
+    src: string[];
+    config: string;
+    disableIds: boolean;
+    disableFormatting: boolean;
+    addGTProvider: boolean;
+};
+export type SetupOptions = {
+    src: string[];
+    config: string;
+};
+export type GenerateSourceOptions = {
+    src: string[];
+    config: string;
+    defaultLocale: string;
+    dictionary?: string;
+    jsconfig?: string;
+    inline?: boolean;
+    ignoreErrors: boolean;
+};
+export type Framework = 'gt-next' | 'gt-react';
+export type SupportedFrameworks = 'next-app' | 'next-pages' | 'vite' | 'gatsby' | 'react' | 'redwood';
+export type SupportedLibraries = 'gt-next' | 'gt-react' | 'next-intl' | 'react-i18next' | 'next-i18next' | 'i18next' | 'i18next-icu' | 'base';
+export interface ContentScanner {
+    scanForContent(options: WrapOptions, framework: Framework): Promise<{
+        errors: string[];
+        filesUpdated: string[];
+        warnings: string[];
+    }>;
+}
+export type SupportedFileExtension = (typeof SUPPORTED_FILE_EXTENSIONS)[number];
+export type ResolvedFiles = {
+    [K in SupportedFileExtension]?: string[];
+} & {
+    gt?: string;
+};
+export type TransformFiles = {
+    [K in SupportedFileExtension]?: string;
+};
+export type FilesOptions = {
+    [K in SupportedFileExtension]?: {
+        include: string[];
+        exclude?: string[];
+        transform?: string;
+    };
+} & {
+    gt?: {
+        output: string;
+    };
+};
+export type Settings = {
+    config: string;
+    baseUrl: string;
+    dashboardUrl: string;
+    apiKey: string;
+    projectId: string;
+    defaultLocale: string;
+    locales: string[];
+    files: {
+        resolvedPaths: ResolvedFiles;
+        placeholderPaths: ResolvedFiles;
+        transformPaths: TransformFiles;
+    } | undefined;
+    stageTranslations: boolean;
+    _versionId?: string;
+    version?: string;
+    description?: string;
+    src?: string[];
+    framework?: SupportedFrameworks;
+};

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const GT_DASHBOARD_URL = "https://dash.generaltranslation.com";

package/dist/utils/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GT_DASHBOARD_URL = void 0;
+exports.GT_DASHBOARD_URL = 'https://dash.generaltranslation.com';

package/dist/utils/credentials.d.ts

@@ -0,0 +1,12 @@
+import { Settings, SupportedFrameworks } from '../types';
+type Credentials = {
+    apiKey: string;
+    projectId: string;
+};
+export declare function retrieveCredentials(settings: Settings, keyType: 'development' | 'production'): Promise<Credentials>;
+export declare function generateCredentialsSession(url: string, keyType: 'development' | 'production'): Promise<{
+    sessionId: string;
+}>;
+export declare function areCredentialsSet(): string | undefined;
+export declare function setCredentials(credentials: Credentials, type: 'development' | 'production', framework?: SupportedFrameworks): Promise<void>;
+export {};

package/dist/utils/credentials.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveCredentials = retrieveCredentials;
+exports.generateCredentialsSession = generateCredentialsSession;
+exports.areCredentialsSet = areCredentialsSet;
+exports.setCredentials = setCredentials;
+const console_1 = require("../console");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const chalk_1 = __importDefault(require("chalk"));
+// Fetches project ID and API key by opening the dashboard in the browser
+async function retrieveCredentials(settings, keyType) {
+    // Generate a session ID
+    const { sessionId } = await generateCredentialsSession(settings.baseUrl, keyType);
+    const urlToOpen = `${settings.dashboardUrl}/cli/wizard/${sessionId}`;
+    await import('open').then((open) => open.default(urlToOpen, {
+        wait: false,
+    }));
+    (0, console_1.logMessage)(`${chalk_1.default.gray(`If the browser window didn't open automatically, please open the following link:`)}\n\n${chalk_1.default.cyan(urlToOpen)}`);
+    const spinner = (0, console_1.createSpinner)('dots');
+    spinner.start('Waiting for response from dashboard...');
+    const credentials = await new Promise(async (resolve, reject) => {
+        const interval = setInterval(async () => {
+            // Ping the dashboard to see if the credentials are set
+            try {
+                const res = await fetch(`${settings.baseUrl}/cli/wizard/${sessionId}`, {
+                    method: 'GET',
+                });
+                if (res.status === 200) {
+                    const data = await res.json();
+                    resolve(data);
+                    clearInterval(interval);
+                    clearTimeout(timeout);
+                    fetch(`${settings.baseUrl}/cli/wizard/${sessionId}`, {
+                        method: 'DELETE',
+                    });
+                }
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }, 2000);
+        // timeout after 1 hour
+        const timeout = setTimeout(() => {
+            spinner.stop('Timed out');
+            clearInterval(interval);
+            (0, console_1.logErrorAndExit)('Timed out waiting for response from dashboard');
+        }, 1000 * 60 * 60);
+    });
+    spinner.stop('Received credentials');
+    return credentials;
+}
+async function generateCredentialsSession(url, keyType) {
+    const res = await fetch(`${url}/cli/wizard/session`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            keyType,
+        }),
+    });
+    if (!res.ok) {
+        (0, console_1.logErrorAndExit)('Failed to generate credentials session');
+    }
+    return await res.json();
+}
+// Checks if the credentials are set in the environment variables
+function areCredentialsSet() {
+    return process.env.GT_PROJECT_ID && process.env.GT_API_KEY;
+}
+// Sets the credentials in .env.local file
+async function setCredentials(credentials, type, framework) {
+    const envFile = node_path_1.default.join(process.cwd(), '.env.local');
+    let envContent = '';
+    // Check if .env.local exists, create it if it doesn't
+    if (!node_fs_1.default.existsSync(envFile)) {
+        // File doesn't exist, create it
+        await node_fs_1.default.promises.writeFile(envFile, '', 'utf8');
+        // Add .env.local to .gitignore if it exists
+        const gitignoreFile = node_path_1.default.join(process.cwd(), '.gitignore');
+        if (node_fs_1.default.existsSync(gitignoreFile)) {
+            const gitignoreContent = await node_fs_1.default.promises.readFile(gitignoreFile, 'utf8');
+            if (!gitignoreContent.includes('.env.local')) {
+                await node_fs_1.default.promises.appendFile(gitignoreFile, '\n.env.local\n', 'utf8');
+            }
+        }
+        else {
+            // Create .gitignore file with .env.local
+            await node_fs_1.default.promises.writeFile(gitignoreFile, '.env.local\n', 'utf8');
+        }
+    }
+    else {
+        // Read existing content
+        envContent = await node_fs_1.default.promises.readFile(envFile, 'utf8');
+    }
+    // Always append the credentials to the file
+    let prefix = '';
+    if (framework === 'next-pages') {
+        prefix = 'NEXT_PUBLIC_';
+    }
+    else if (framework === 'vite') {
+        prefix = 'VITE_';
+    }
+    else if (framework === 'gatsby') {
+        prefix = 'GATSBY_';
+    }
+    else if (framework === 'react') {
+        prefix = 'REACT_APP_';
+    }
+    else if (framework === 'redwood') {
+        prefix = 'REDWOOD_ENV_';
+    }
+    envContent += `\n${prefix}GT_PROJECT_ID=${credentials.projectId}\n`;
+    if (type === 'development') {
+        envContent += `${prefix || ''}GT_DEV_API_KEY=${credentials.apiKey}\n`;
+    }
+    else {
+        envContent += `GT_API_KEY=${credentials.apiKey}\n`;
+    }
+    // Ensure we don't have excessive newlines
+    envContent = envContent.replace(/\n{3,}/g, '\n\n').trim() + '\n';
+    // Write the updated content back to the file
+    await node_fs_1.default.promises.writeFile(envFile, envContent, 'utf8');
+}

package/dist/utils/installPackage.d.ts

@@ -0,0 +1,2 @@
+import { PackageManager } from './packageManager';
+export declare function installPackage(packageName: string, packageManager: PackageManager, asDevDependency?: boolean): Promise<void>;

package/dist/utils/installPackage.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPackage = installPackage;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const console_1 = require("../console");
+async function installPackage(packageName, packageManager, asDevDependency) {
+    return new Promise((resolve, reject) => {
+        const command = packageManager.name;
+        const args = [packageManager.installCommand, packageName];
+        if (asDevDependency) {
+            args.push(packageManager.devDependencyFlag);
+        }
+        const childProcess = (0, child_process_1.spawn)(command, args, {
+            stdio: ['pipe', 'ignore', 'pipe'],
+        });
+        let errorOutput = '';
+        if (childProcess.stderr) {
+            childProcess.stderr.on('data', (data) => {
+                errorOutput += data.toString();
+            });
+        }
+        childProcess.on('error', (error) => {
+            (0, console_1.logError)(chalk_1.default.red(`Installation error: ${error.message}`));
+            (0, console_1.logInfo)(`Please manually install ${packageName} with: ${packageManager.name} ${packageManager.installCommand} ${packageName}`);
+            reject(error);
+        });
+        childProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                (0, console_1.logError)(chalk_1.default.red(`Installation failed with exit code ${code}`));
+                if (errorOutput) {
+                    (0, console_1.logError)(chalk_1.default.red(`Error details: ${errorOutput}`));
+                }
+                (0, console_1.logInfo)(`Please manually install ${packageName} with: ${packageManager.name} ${packageManager.installCommand} ${packageName}`);
+                reject(new Error(`Process exited with code ${code}`));
+            }
+        });
+    });
+}

package/dist/utils/packageJson.d.ts

@@ -0,0 +1,5 @@
+export declare function searchForPackageJson(): Promise<Record<string, any> | null>;
+export declare function getPackageJson(): Promise<Record<string, any>>;
+export declare function updatePackageJson(packageJson: Record<string, any>): Promise<void>;
+export declare function isPackageInstalled(packageName: string, packageJson: Record<string, any>, asDevDependency?: boolean, checkBoth?: boolean): boolean;
+export declare function getPackageVersion(packageName: string, packageJson: Record<string, any>): string | undefined;

package/dist/utils/packageJson.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchForPackageJson = searchForPackageJson;
+exports.getPackageJson = getPackageJson;
+exports.updatePackageJson = updatePackageJson;
+exports.isPackageInstalled = isPackageInstalled;
+exports.getPackageVersion = getPackageVersion;
+const console_1 = require("../console");
+const chalk_1 = __importDefault(require("chalk"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const console_2 = require("../console");
+// search for package.json such that we can run init in non-js projects
+async function searchForPackageJson() {
+    // Get the current working directory (where the CLI is being run)
+    const cwd = process.cwd();
+    const packageJsonPath = node_path_1.default.join(cwd, 'package.json');
+    // Check if package.json exists
+    if (!node_fs_1.default.existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(await node_fs_1.default.promises.readFile(packageJsonPath, 'utf8'));
+    }
+    catch (error) {
+        return null;
+    }
+}
+async function getPackageJson() {
+    // Get the current working directory (where the CLI is being run)
+    const cwd = process.cwd();
+    const packageJsonPath = node_path_1.default.join(cwd, 'package.json');
+    // Check if package.json exists
+    if (!node_fs_1.default.existsSync(packageJsonPath)) {
+        (0, console_2.logErrorAndExit)(chalk_1.default.red('No package.json found in the current directory. Please run this command from the root of your project.'));
+    }
+    try {
+        return JSON.parse(await node_fs_1.default.promises.readFile(packageJsonPath, 'utf8'));
+    }
+    catch (error) {
+        (0, console_1.logError)(chalk_1.default.red('Error parsing package.json: ' + String(error)));
+        process.exit(1);
+    }
+}
+async function updatePackageJson(packageJson) {
+    try {
+        await node_fs_1.default.promises.writeFile(node_path_1.default.join(process.cwd(), 'package.json'), JSON.stringify(packageJson, null, 2));
+    }
+    catch (error) {
+        (0, console_1.logError)(chalk_1.default.red('Error updating package.json: ' + String(error)));
+        process.exit(1);
+    }
+}
+// check if a package is installed in the package.json file
+function isPackageInstalled(packageName, packageJson, asDevDependency = false, checkBoth = false) {
+    const dependencies = checkBoth
+        ? {
+            ...packageJson.devDependencies,
+            ...packageJson.dependencies,
+        }
+        : asDevDependency
+            ? packageJson.devDependencies
+            : packageJson.dependencies;
+    if (!dependencies) {
+        return false;
+    }
+    return dependencies[packageName] !== undefined;
+}
+function getPackageVersion(packageName, packageJson) {
+    const dependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    };
+    return dependencies[packageName] ?? undefined;
+}

package/dist/utils/packageManager.d.ts

@@ -0,0 +1,23 @@
+export interface PackageManager {
+    name: string;
+    label: string;
+    installCommand: string;
+    buildCommand: string;
+    runScriptCommand: string;
+    flags: string;
+    forceInstallFlag: string;
+    devDependencyFlag: string;
+    registry?: string;
+    detect: () => boolean;
+    addOverride: (pkgName: string, pkgVersion: string) => Promise<void>;
+}
+export declare const BUN: PackageManager;
+export declare const DENO: PackageManager;
+export declare const YARN_V1: PackageManager;
+/** YARN V2/3/4 */
+export declare const YARN_V2: PackageManager;
+export declare const PNPM: PackageManager;
+export declare const NPM: PackageManager;
+export declare const packageManagers: PackageManager[];
+export declare function _detectPackageManger(managers?: PackageManager[]): PackageManager | null;
+export declare function getPackageManager(): Promise<PackageManager>;