gt 0.10.0 → 2.7.0

package/dist/cli/next.js

@@ -0,0 +1,12 @@
+import { ReactCLI } from './react.js';
+import { wrapContentNext } from '../next/parse/wrapContent.js';
+import { Libraries } from '../types/libraries.js';
+const pkg = Libraries.GT_NEXT;
+export class NextCLI extends ReactCLI {
+    constructor(command, library, additionalModules) {
+        super(command, library, additionalModules);
+    }
+    wrapContent(options, framework, errors, warnings) {
+        return wrapContentNext(options, pkg, errors, warnings);
+    }
+}

package/dist/cli/node.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import { SupportedLibraries } from '../types/index.js';
+import { InlineCLI } from './inline.js';
+import { Libraries } from '../types/libraries.js';
+/**
+ * CLI tool for managing translations with gt-node
+ */
+export declare class NodeCLI extends InlineCLI {
+    constructor(command: Command, library: typeof Libraries.GT_NODE, additionalModules?: SupportedLibraries[]);
+}

package/dist/cli/node.js

@@ -0,0 +1,9 @@
+import { InlineCLI } from './inline.js';
+/**
+ * CLI tool for managing translations with gt-node
+ */
+export class NodeCLI extends InlineCLI {
+    constructor(command, library, additionalModules) {
+        super(command, library, additionalModules);
+    }
+}

package/dist/cli/react.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import { Framework, SupportedFrameworks, WrapOptions, SupportedLibraries } from '../types/index.js';
+import { InlineCLI } from './inline.js';
+export declare class ReactCLI extends InlineCLI {
+    constructor(command: Command, library: Framework, additionalModules?: SupportedLibraries[]);
+    init(): void;
+    protected wrapContent(options: WrapOptions, framework: SupportedFrameworks, errors: string[], warnings: string[]): Promise<{
+        filesUpdated: string[];
+    }>;
+    protected setupSetupProjectCommand(): void;
+    protected handleScanCommand(options: WrapOptions): Promise<void>;
+}

package/dist/cli/react.js

@@ -0,0 +1,72 @@
+import { displayHeader, exitSync, promptConfirm } from '../console/logging.js';
+import { logger } from '../console/logger.js';
+import chalk from 'chalk';
+import { formatFiles } from '../hooks/postProcess.js';
+import { wrapContentReact } from '../react/parse/wrapContent.js';
+import { generateSettings } from '../config/generateSettings.js';
+import { attachInlineTranslateFlags, attachTranslateFlags } from './flags.js';
+import { InlineCLI } from './inline.js';
+import { Libraries } from '../types/libraries.js';
+const pkg = Libraries.GT_REACT;
+export class ReactCLI extends InlineCLI {
+    constructor(command, library, additionalModules) {
+        super(command, library, additionalModules);
+    }
+    init() {
+        super.init();
+        this.setupSetupProjectCommand();
+    }
+    wrapContent(options, framework, errors, warnings) {
+        return wrapContentReact(options, pkg, framework, errors, warnings);
+    }
+    setupSetupProjectCommand() {
+        attachInlineTranslateFlags(attachTranslateFlags(this.program
+            .command('setup')
+            .description('Upload source files and setup the project for translation'))).action(async (options) => {
+            displayHeader('Uploading source files and setting up project...');
+            await this.handleSetupProject(options);
+            logger.endCommand('Done!');
+        });
+    }
+    async handleScanCommand(options) {
+        // Ask user for confirmation using inquirer
+        const answer = await promptConfirm({
+            message: chalk.yellow('Warning: This operation will modify your source files! Make sure you have committed or stashed your current changes. Do you want to continue?'),
+            defaultValue: true,
+        });
+        if (!answer) {
+            logger.error('Operation cancelled.');
+            exitSync(0);
+        }
+        // ----- Create a starter gt.config.json file -----
+        await generateSettings(options);
+        // ----- //
+        const includeTId = await promptConfirm({
+            message: 'Do you want to include an unique id for each <T> tag?',
+            defaultValue: true,
+        });
+        options.disableIds = !includeTId;
+        const errors = [];
+        const warnings = [];
+        // Wrap all JSX elements in the src directory with a <T> tag, with unique ids
+        const { filesUpdated } = await this.wrapContent(options, 'react', errors, warnings);
+        if (errors.length > 0) {
+            logger.error(chalk.red('Failed to write files:\n') + errors.join('\n'));
+        }
+        // Format updated files if formatters are available
+        if (!options.disableFormatting)
+            await formatFiles(filesUpdated);
+        logger.success(`Success! Added <T> tags and updated ${chalk.bold.cyan(filesUpdated.length)} files:\n` +
+            filesUpdated.map((file) => `${chalk.green('-')} ${file}`).join('\n'));
+        if (filesUpdated.length > 0) {
+            logger.step(chalk.green('Please verify the changes before committing.'));
+        }
+        if (warnings.length > 0) {
+            logger.warn(chalk.yellow('Warnings encountered:') +
+                '\n' +
+                warnings
+                    .map((warning) => `${chalk.yellow('-')} ${warning}`)
+                    .join('\n'));
+        }
+    }
+}

package/dist/config/generateSettings.d.ts

@@ -0,0 +1,9 @@
+import { Settings } from '../types/index.js';
+export declare const DEFAULT_SRC_PATTERNS: string[];
+/**
+ * Generates settings from any
+ * @param flags - The CLI flags to generate settings from
+ * @param cwd - The current working directory
+ * @returns The generated settings
+ */
+export declare function generateSettings(flags: Record<string, any>, cwd?: string): Promise<Settings>;

package/dist/config/generateSettings.js

@@ -0,0 +1,214 @@
+import { displayProjectId, exitSync, logErrorAndExit, warnApiKeyInConfig, } from '../console/logging.js';
+import { loadConfig } from '../fs/config/loadConfig.js';
+import { defaultBaseUrl, libraryDefaultLocale, } from 'generaltranslation/internal';
+import fs from 'node:fs';
+import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
+import { resolveFiles } from '../fs/config/parseFilesConfig.js';
+import { validateSettings } from './validateSettings.js';
+import { DEFAULT_GIT_REMOTE_NAME, GT_DASHBOARD_URL, } from '../utils/constants.js';
+import { resolveProjectId } from '../fs/utils.js';
+import path from 'node:path';
+import chalk from 'chalk';
+import { resolveConfig } from './resolveConfig.js';
+import { gt } from '../utils/gt.js';
+import { generatePreset } from './optionPresets.js';
+export const DEFAULT_SRC_PATTERNS = [
+    'src/**/*.{js,jsx,ts,tsx}',
+    'app/**/*.{js,jsx,ts,tsx}',
+    'pages/**/*.{js,jsx,ts,tsx}',
+    'components/**/*.{js,jsx,ts,tsx}',
+];
+/**
+ * Generates settings from any
+ * @param flags - The CLI flags to generate settings from
+ * @param cwd - The current working directory
+ * @returns The generated settings
+ */
+export async function generateSettings(flags, cwd = process.cwd()) {
+    // Load config file
+    let gtConfig = {};
+    if (flags.config && !flags.config.endsWith('.json')) {
+        flags.config = `${flags.config}.json`;
+    }
+    if (flags.config) {
+        gtConfig = loadConfig(flags.config);
+    }
+    else {
+        const config = resolveConfig(cwd);
+        if (config) {
+            gtConfig = config.config;
+            flags.config = config.path;
+        }
+        else {
+            gtConfig = {};
+        }
+    }
+    // Warn if apiKey is present in gt.config.json
+    if (gtConfig.apiKey) {
+        warnApiKeyInConfig(flags.config);
+        exitSync(1);
+    }
+    const projectIdEnv = resolveProjectId();
+    // Resolve mismatched projectIds
+    if (gtConfig.projectId &&
+        flags.projectId &&
+        gtConfig.projectId !== flags.projectId) {
+        logErrorAndExit(`Project ID mismatch between ${chalk.green(gtConfig.projectId)} and ${chalk.green(flags.projectId)}! Please use the same projectId in all configs.`);
+    }
+    else if (gtConfig.projectId &&
+        projectIdEnv &&
+        gtConfig.projectId !== projectIdEnv) {
+        logErrorAndExit(`Project ID mismatch between ${chalk.green(gtConfig.projectId)} and ${chalk.green(projectIdEnv)}! Please use the same projectId in all configs.`);
+    }
+    if (flags.options?.docsUrlPattern &&
+        !flags.options?.docsUrlPattern.includes('[locale]')) {
+        logErrorAndExit('Failed to localize static urls: URL pattern must include "[locale]" to denote the location of the locale');
+    }
+    if (flags.options?.docsImportPattern &&
+        !flags.options?.docsImportPattern.includes('[locale]')) {
+        logErrorAndExit('Failed to localize static imports: Import pattern must include "[locale]" to denote the location of the locale');
+    }
+    if (flags.options?.copyFiles) {
+        for (const file of flags.options.copyFiles) {
+            if (!file.includes('[locale]')) {
+                logErrorAndExit('Failed to copy files: File path must include "[locale]" to denote the location of the locale');
+            }
+        }
+    }
+    // merge options
+    const mergedOptions = { ...gtConfig, ...flags };
+    // Add defaultLocale if not provided
+    mergedOptions.defaultLocale =
+        mergedOptions.defaultLocale || libraryDefaultLocale;
+    // merge locales
+    mergedOptions.locales = Array.from(new Set([...(gtConfig.locales || []), ...(flags.locales || [])]));
+    // Separate defaultLocale from locales
+    mergedOptions.locales = mergedOptions.locales.filter((locale) => locale !== mergedOptions.defaultLocale);
+    // Add apiKey if not provided
+    mergedOptions.apiKey = mergedOptions.apiKey || process.env.GT_API_KEY;
+    // Add projectId if not provided
+    mergedOptions.projectId = mergedOptions.projectId || resolveProjectId();
+    // Add baseUrl if not provided
+    mergedOptions.baseUrl = mergedOptions.baseUrl || defaultBaseUrl;
+    // Add dashboardUrl if not provided
+    mergedOptions.dashboardUrl = mergedOptions.dashboardUrl || GT_DASHBOARD_URL;
+    // Add locales if not provided
+    mergedOptions.locales = mergedOptions.locales || [];
+    // Add default config file name if not provided
+    mergedOptions.config =
+        mergedOptions.config || path.join(cwd, 'gt.config.json');
+    // Display projectId if present
+    if (mergedOptions.projectId)
+        displayProjectId(mergedOptions.projectId);
+    // Add stageTranslations if not provided
+    // For human review, always stage the project
+    mergedOptions.stageTranslations = mergedOptions.stageTranslations ?? false;
+    // Add publish if not provided
+    mergedOptions.publish = (gtConfig.publish || flags.publish) ?? false;
+    // Populate src if not provided
+    mergedOptions.src = mergedOptions.src || DEFAULT_SRC_PATTERNS;
+    // Resolve all glob patterns in the files object
+    const compositePatterns = [
+        ...Object.entries(mergedOptions.options?.jsonSchema || {}),
+    ]
+        .filter(([, schema]) => schema.composite)
+        .map(([key]) => key);
+    mergedOptions.files = mergedOptions.files
+        ? resolveFiles(mergedOptions.files, mergedOptions.defaultLocale, mergedOptions.locales, cwd, compositePatterns)
+        : { resolvedPaths: {}, placeholderPaths: {}, transformPaths: {} };
+    mergedOptions.options = {
+        ...(mergedOptions.options || {}),
+        mintlify: {
+            ...(mergedOptions.options?.mintlify || {}),
+            inferTitleFromFilename: gtConfig.options?.mintlify?.inferTitleFromFilename ||
+                mergedOptions.options?.mintlify?.inferTitleFromFilename,
+        },
+        experimentalLocalizeStaticImports: gtConfig.options?.experimentalLocalizeStaticImports ||
+            flags.experimentalLocalizeStaticImports,
+        experimentalLocalizeStaticUrls: gtConfig.options?.experimentalLocalizeStaticUrls ||
+            flags.experimentalLocalizeStaticUrls,
+        experimentalLocalizeRelativeAssets: gtConfig.options?.experimentalLocalizeRelativeAssets ||
+            flags.experimentalLocalizeRelativeAssets,
+        experimentalHideDefaultLocale: gtConfig.options?.experimentalHideDefaultLocale ||
+            flags.experimentalHideDefaultLocale,
+        experimentalFlattenJsonFiles: gtConfig.options?.experimentalFlattenJsonFiles ||
+            flags.experimentalFlattenJsonFiles,
+        experimentalClearLocaleDirs: gtConfig.options?.experimentalClearLocaleDirs ||
+            flags.experimentalClearLocaleDirs,
+        clearLocaleDirsExclude: gtConfig.options?.clearLocaleDirsExclude || flags.clearLocaleDirsExclude,
+    };
+    // Add additional options if provided
+    if (mergedOptions.options) {
+        if (mergedOptions.options.jsonSchema) {
+            for (const fileGlob of Object.keys(mergedOptions.options.jsonSchema)) {
+                const jsonSchema = mergedOptions.options.jsonSchema[fileGlob];
+                if (jsonSchema.preset) {
+                    mergedOptions.options.jsonSchema[fileGlob] = {
+                        ...generatePreset(jsonSchema.preset, 'json'),
+                        ...jsonSchema,
+                    };
+                }
+            }
+        }
+        if (mergedOptions.options.yamlSchema) {
+            for (const fileGlob of Object.keys(mergedOptions.options.yamlSchema)) {
+                const yamlSchema = mergedOptions.options.yamlSchema[fileGlob];
+                if (yamlSchema.preset) {
+                    mergedOptions.options.yamlSchema[fileGlob] = {
+                        ...generatePreset(yamlSchema.preset, 'yaml'),
+                        ...yamlSchema,
+                    };
+                }
+            }
+        }
+    }
+    // Add parsing options if not provided
+    mergedOptions.parsingOptions = mergedOptions.parsingOptions || {};
+    mergedOptions.parsingOptions.conditionNames = mergedOptions.parsingOptions
+        .conditionNames || [
+        'development',
+        'browser',
+        'module',
+        'import',
+        'require',
+        'default',
+    ];
+    // Add branch options if not provided
+    const branchOptions = mergedOptions.branchOptions || {};
+    // If --branch is set, enable branching
+    branchOptions.enabled =
+        flags.enableBranching ??
+            gtConfig.branchOptions?.enabled ??
+            (flags.branch ? true : false);
+    branchOptions.currentBranch =
+        flags.branch ?? gtConfig.branchOptions?.currentBranch ?? undefined;
+    branchOptions.autoDetectBranches = flags.disableBranchDetection
+        ? false
+        : (gtConfig.branchOptions?.autoDetectBranches ?? true);
+    branchOptions.remoteName =
+        flags.remoteName ??
+            gtConfig.branchOptions?.remoteName ??
+            DEFAULT_GIT_REMOTE_NAME;
+    mergedOptions.branchOptions = branchOptions;
+    // if there's no existing config file, creates one
+    // does not include the API key to avoid exposing it
+    if (!fs.existsSync(mergedOptions.config)) {
+        await createOrUpdateConfig(mergedOptions.config, {
+            projectId: mergedOptions.projectId,
+            defaultLocale: mergedOptions.defaultLocale,
+            locales: mergedOptions.locales?.length > 0 ? mergedOptions.locales : undefined,
+            framework: mergedOptions.framework,
+        });
+    }
+    mergedOptions.configDirectory = path.join(cwd, '.gt');
+    validateSettings(mergedOptions);
+    // Set up GT instance
+    gt.setConfig({
+        projectId: mergedOptions.projectId,
+        apiKey: mergedOptions.apiKey,
+        baseUrl: mergedOptions.baseUrl,
+        sourceLocale: mergedOptions.defaultLocale,
+        customMapping: mergedOptions.customMapping,
+    });
+    return mergedOptions;
+}

package/dist/config/optionPresets.d.ts

@@ -0,0 +1,3 @@
+import { JsonSchema, YamlSchema } from '../types/index.js';
+export declare function generatePreset(preset: JsonSchema['preset'], type: 'json'): JsonSchema;
+export declare function generatePreset(preset: YamlSchema['preset'], type: 'yaml'): YamlSchema;

package/dist/config/optionPresets.js

@@ -0,0 +1,65 @@
+export function generatePreset(preset, type) {
+    if (type === 'json') {
+        switch (preset) {
+            case 'mintlify':
+                // https://mintlify.com/docs/navigation
+                return {
+                    composite: {
+                        '$.navigation.languages': {
+                            type: 'array',
+                            key: '$.language',
+                            experimentalSort: 'localesAlphabetical',
+                            include: [
+                                '$..group',
+                                '$..tab',
+                                '$..item',
+                                '$..anchor',
+                                '$..dropdown',
+                            ],
+                            transform: {
+                                '$..pages[*]': {
+                                    match: '^{locale}/(.*)$',
+                                    replace: '{locale}/$1',
+                                },
+                            },
+                        },
+                        '$.redirects': {
+                            type: 'array',
+                            key: '$.language',
+                            include: [],
+                            transform: {
+                                '$.source': {
+                                    match: '^/{locale}/(.*)$',
+                                    replace: '/{locale}/$1',
+                                },
+                                '$.destination': {
+                                    match: '^/{locale}/(.*)$',
+                                    replace: '/{locale}/$1',
+                                },
+                            },
+                        },
+                    },
+                };
+            case 'openapi':
+                return {
+                    include: ['$..summary', '$..description'],
+                };
+            default:
+                return {};
+        }
+    }
+    else {
+        switch (preset) {
+            case 'mintlify':
+                return {
+                    include: ['$..summary', '$..description'],
+                };
+            case 'openapi':
+                return {
+                    include: ['$..summary', '$..description'],
+                };
+            default:
+                return {};
+        }
+    }
+}

package/dist/config/resolveConfig.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveConfig(cwd: string): {
+    path: string;
+    config: Record<string, any>;
+} | null;

package/dist/config/resolveConfig.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from '../fs/config/loadConfig.js';
+export function resolveConfig(cwd) {
+    const configFilepath = 'gt.config.json';
+    if (fs.existsSync(path.join(cwd, configFilepath))) {
+        return {
+            path: path.join(cwd, configFilepath),
+            config: loadConfig(path.join(cwd, configFilepath)),
+        };
+    }
+    if (fs.existsSync(path.join(cwd, 'src/gt.config.json'))) {
+        return {
+            path: path.join(cwd, 'src/gt.config.json'),
+            config: loadConfig(path.join(cwd, 'src/gt.config.json')),
+        };
+    }
+    // Support config under .gt for parity with .locadex
+    if (fs.existsSync(path.join(cwd, '.gt/gt.config.json'))) {
+        return {
+            path: path.join(cwd, '.gt/gt.config.json'),
+            config: loadConfig(path.join(cwd, '.gt/gt.config.json')),
+        };
+    }
+    // Backward compatibility: support legacy .locadex directory
+    if (fs.existsSync(path.join(cwd, '.locadex/gt.config.json'))) {
+        return {
+            path: path.join(cwd, '.locadex/gt.config.json'),
+            config: loadConfig(path.join(cwd, '.locadex/gt.config.json')),
+        };
+    }
+    return null;
+}

package/dist/config/utils.d.ts

@@ -0,0 +1,2 @@
+import { Settings } from '../types/index.js';
+export declare function isUsingLocalTranslations(settings: Settings): boolean;

package/dist/config/utils.js

@@ -0,0 +1,4 @@
+// returns true if the project is configured to use local translations
+export function isUsingLocalTranslations(settings) {
+    return !!(settings.files && settings.files.placeholderPaths.gt);
+}

package/dist/config/validateSettings.d.ts

@@ -0,0 +1,3 @@
+import { Settings } from '../types/index.js';
+export declare function validateSettings(settings: Settings): undefined;
+export declare function validateConfigExists(): string;

package/dist/config/validateSettings.js

@@ -0,0 +1,32 @@
+import { isValidLocale, isSupersetLocale } from 'generaltranslation';
+import { logErrorAndExit } from '../console/logging.js';
+import fs from 'node:fs';
+import path from 'node:path';
+export function validateSettings(settings) {
+    // Validate locales
+    for (const locale of settings.locales) {
+        if (!isValidLocale(locale, settings.customMapping)) {
+            return logErrorAndExit(`Provided locales: "${settings?.locales?.join()}", ${locale} is not a valid locale!`);
+        }
+    }
+    if (settings.defaultLocale &&
+        !isValidLocale(settings.defaultLocale, settings.customMapping)) {
+        return logErrorAndExit(`defaultLocale: ${settings.defaultLocale} is not a valid locale!`);
+    }
+    // defaultLocale cannot be a superset of any other locale
+    if (settings.defaultLocale &&
+        settings.locales.some((locale) => isSupersetLocale(settings.defaultLocale, locale) &&
+            !isSupersetLocale(locale, settings.defaultLocale))) {
+        const locale = settings.locales.find((locale) => isSupersetLocale(settings.defaultLocale, locale));
+        return logErrorAndExit(`defaultLocale: ${settings.defaultLocale} is a superset of another locale (${locale})! Please change the defaultLocale to a more specific locale.`);
+    }
+}
+export function validateConfigExists() {
+    const possibleConfigPaths = ['gt.config.json', 'src/gt.config.json'];
+    for (const possibleConfigPath of possibleConfigPaths) {
+        if (fs.existsSync(path.resolve(path.relative(process.cwd(), possibleConfigPath)))) {
+            return possibleConfigPath;
+        }
+    }
+    return logErrorAndExit('No gt.config.json file found. Are you in the correct directory?');
+}

package/dist/console/colors.d.ts

@@ -0,0 +1,6 @@
+export declare function colorizeFilepath(filepath: string): string;
+export declare function colorizeComponent(component: string): string;
+export declare function colorizeFunctionName(functionName: string): string;
+export declare function colorizeIdString(id: string): string;
+export declare function colorizeContent(content: string): string;
+export declare function colorizeLine(line: string): string;

package/dist/console/colors.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+export function colorizeFilepath(filepath) {
+    return chalk.cyan(filepath);
+}
+export function colorizeComponent(component) {
+    return chalk.yellow(component);
+}
+export function colorizeFunctionName(functionName) {
+    return chalk.yellow(functionName);
+}
+export function colorizeIdString(id) {
+    return chalk.yellow(id);
+}
+export function colorizeContent(content) {
+    return chalk.yellow(content);
+}
+export function colorizeLine(line) {
+    return chalk.dim(line);
+}

package/dist/console/displayTranslateSummary.d.ts

@@ -0,0 +1 @@
+export declare function displayTranslateSummary(): void;

package/dist/console/displayTranslateSummary.js

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+import { logger } from './logger.js';
+import { getWarnings, hasWarnings, } from '../state/translateWarnings.js';
+const CATEGORY_LABELS = {
+    skipped_file: 'Files skipped',
+    failed_move: 'File moves failed',
+    failed_translation: 'Translations failed',
+    failed_download: 'Downloads failed',
+};
+const CATEGORY_ORDER = [
+    'skipped_file',
+    'failed_move',
+    'failed_translation',
+    'failed_download',
+];
+export function displayTranslateSummary() {
+    if (!hasWarnings())
+        return;
+    const warnings = getWarnings();
+    // Group by category
+    const grouped = new Map();
+    for (const w of warnings) {
+        let list = grouped.get(w.category);
+        if (!list) {
+            list = [];
+            grouped.set(w.category, list);
+        }
+        list.push({ fileName: w.fileName, reason: w.reason });
+    }
+    const lines = [chalk.yellow('⚠  Warnings:'), ''];
+    for (const category of CATEGORY_ORDER) {
+        const items = grouped.get(category);
+        if (!items)
+            continue;
+        lines.push(`    ${CATEGORY_LABELS[category]} (${items.length}):`);
+        for (const item of items) {
+            lines.push(`      - ${item.fileName}: ${item.reason}`);
+        }
+        lines.push('');
+    }
+    logger.warn(lines.join('\n'));
+}

package/dist/console/formatting.d.ts

@@ -0,0 +1 @@
+export declare function formatCodeClamp(code: string): string;

package/dist/console/formatting.js

@@ -0,0 +1,7 @@
+const MAX_CODE_GEN_LENGTH = 100;
+export function formatCodeClamp(code) {
+    if (code.length <= MAX_CODE_GEN_LENGTH) {
+        return code;
+    }
+    return `${code.slice(0, MAX_CODE_GEN_LENGTH)}...`;
+}

package/dist/console/index.d.ts

@@ -0,0 +1,34 @@
+export declare const warnApiKeyInConfigSync: (optionsFilepath: string) => string;
+export declare const warnVariablePropSync: (file: string, attrName: string, value: string, location?: string) => string;
+export declare const warnInvalidReturnSync: (file: string, functionName: string, expression: string, location?: string) => string;
+export declare const warnMissingReturnSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnHasUnwrappedExpressionSync: (file: string, unwrappedExpressions: string[], id?: string, location?: string) => string;
+export declare const warnFailedToConstructJsxTreeSync: (file: string, code: string, location?: string) => string;
+export declare const warnNestedTComponent: (file: string, location?: string) => string;
+export declare const warnNonStaticExpressionSync: (file: string, attrName: string, value: string, location?: string) => string;
+export declare const warnInvalidMaxCharsSync: (file: string, value: string, location?: string) => string;
+export declare const warnInvalidIcuSync: (file: string, value: string, error: string, location?: string) => string;
+export declare const warnTemplateLiteralSync: (file: string, value: string, location?: string) => string;
+export declare const warnNonStringSync: (file: string, value: string, location?: string) => string;
+export declare const warnAsyncUseGT: (file: string, location?: string) => string;
+export declare const warnSyncGetGT: (file: string, location?: string) => string;
+export declare const warnTernarySync: (file: string, location?: string) => string;
+export declare const withLocation: (file: string, message: string, location?: string) => string;
+export declare const warnFunctionNotFoundSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnInvalidDeclareVarNameSync: (file: string, value: string, location?: string) => string;
+export declare const warnDuplicateFunctionDefinitionSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnInvalidStaticInitSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnDataAttrOnBranch: (file: string, attrName: string, location?: string) => string;
+export declare const warnRecursiveFunctionCallSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnDeclareStaticNotWrappedSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnDeclareStaticNoResultsSync: (file: string, functionName: string, location?: string) => string;
+export declare const noLocalesError = "No locales found! Please provide a list of locales for translation, or specify them in your gt.config.json file.";
+export declare const noDefaultLocaleError = "No default locale found! Please provide a default locale, or specify it in your gt.config.json file.";
+export declare const noFilesError = "Incorrect or missing files configuration! Please make sure your files are configured correctly in your gt.config.json file.";
+export declare const noSourceFileError = "No source file found! Please double check your translations directory and default locale.";
+export declare const noSupportedFormatError = "Unsupported data format! Please make sure your translationsDir parameter ends with a supported file extension.";
+export declare const noApiKeyError = "No API key found! Please provide an API key using the --api-key flag or set the GT_API_KEY environment variable.";
+export declare const devApiKeyError = "You are using a development API key. Please use a production API key to use the General Translation API.\nYou can generate a production API key with the command: npx gt auth -t production";
+export declare const noProjectIdError = "No project ID found! Please provide a project ID using the --project-id flag, specify it in your gt.config.json file, or set the GT_PROJECT_ID environment variable.";
+export declare const noVersionIdError = "No version ID found! Please provide a version ID using the --version-id flag or specify it in your gt.config.json file as the _versionId property.";
+export declare const invalidConfigurationError = "Invalid files configuration! Please either provide a valid configuration to download local translations or set the --publish flag to true to upload translations to the CDN.";