gtx-cli 2.0.5 → 2.0.6-alpha.6

package/dist/api/waitForUpdates.js

@@ -1,67 +1,61 @@
 import chalk from 'chalk';
 import { createOraSpinner, logErrorAndExit, } from '../console/logging.js';
 import { getLocaleProperties } from 'generaltranslation';
-import { getAuthHeaders } from '../utils/headers.js';
+import { gt } from '../utils/gt.js';
 /**
  * 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 const waitForUpdates = async (projectId, apiKey, baseUrl, versionId, startTime, timeoutDuration) => {
+export const waitForUpdates = async (versionId, startTime, timeoutDuration) => {
     console.log();
     const spinner = await createOraSpinner();
     spinner.start('Waiting for translation...');
     const checkDeployment = async () => {
+        let data;
         try {
-            const response = await fetch(`${baseUrl}/v1/project/translations/status/${encodeURIComponent(versionId)}`, {
-                method: 'GET',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...getAuthHeaders(projectId, apiKey),
-                },
-            });
-            if (response.ok) {
-                const data = await response.json();
-                const { availableLocales, locales, localesWaitingForApproval } = data;
-                if (localesWaitingForApproval.length > 0) {
-                    spinner.stop();
-                    logErrorAndExit(`Error! ${localesWaitingForApproval.length} translations are waiting for approval:\n${localesWaitingForApproval
-                        .map((locale) => {
-                        const localeProperties = getLocaleProperties(locale);
-                        return `${localeProperties.name} (${localeProperties.code})`;
-                    })
-                        .join('\n')}\nPlease approve these locales in the General Translation dashboard, then re-run the command.`);
-                }
-                if (availableLocales) {
-                    availableLocales.forEach((locale) => {
-                        if (!availableLocales.includes(locale)) {
-                            availableLocales.push(locale);
-                        }
-                    });
-                    const newSuffixText = [
-                        chalk.green(`[${availableLocales.length}/${locales.length}]`) +
-                            ` translations completed`,
-                        ...availableLocales.map((locale) => {
-                            const localeProperties = getLocaleProperties(locale);
-                            return `Translation completed for ${chalk.green(localeProperties.name)} (${chalk.green(localeProperties.code)})`;
-                        }),
-                    ];
-                    spinner.text = newSuffixText.join('\n');
-                }
-                if (locales.every((locale) => availableLocales.includes(locale))) {
-                    return true;
-                }
-            }
-            return false;
+            // get translation status
+            data = await gt.checkTranslationStatus(versionId);
         }
-        catch (error) {
+        catch {
             return false;
         }
+        // check if any locales are waiting for approval
+        const { availableLocales, locales, localesWaitingForApproval } = data;
+        if (localesWaitingForApproval.length > 0) {
+            spinner.stop();
+            logErrorAndExit(`Error! ${localesWaitingForApproval.length} translations are waiting for approval:\n${localesWaitingForApproval
+                .map((locale) => {
+                const localeProperties = getLocaleProperties(locale);
+                return `${localeProperties.name} (${localeProperties.code})`;
+            })
+                .join('\n')}\nPlease approve these locales in the General Translation dashboard, then re-run the command.`);
+        }
+        // check if all locales are available
+        if (availableLocales) {
+            availableLocales.forEach((locale) => {
+                if (!availableLocales.includes(locale)) {
+                    availableLocales.push(locale);
+                }
+            });
+            const newSuffixText = [
+                chalk.green(`[${availableLocales.length}/${locales.length}]`) +
+                    ` translations completed`,
+                ...availableLocales.map((locale) => {
+                    const localeProperties = getLocaleProperties(locale);
+                    return `Translation completed for ${chalk.green(localeProperties.name)} (${chalk.green(localeProperties.code)})`;
+                }),
+            ];
+            spinner.text = newSuffixText.join('\n');
+        }
+        // check if all locales are available
+        if (locales.every((locale) => availableLocales.includes(locale))) {
+            return true;
+        }
+        return false;
     };
     // Calculate time until next 5-second interval since startTime
     const msUntilNextInterval = Math.max(0, 5000 - ((Date.now() - startTime) % 5000));

package/dist/cli/base.d.ts

@@ -7,6 +7,9 @@ export type TranslateOptions = {
     apiKey?: string;
     projectId?: string;
     dryRun: boolean;
+    experimentalLocalizeStaticUrls?: boolean;
+    experimentalHideDefaultLocale?: boolean;
+    experimentalFlattenJsonFiles?: boolean;
 };
 export type LoginOptions = {
     keyType?: 'development' | 'production';

package/dist/cli/base.js

@@ -14,6 +14,8 @@ import { installPackage } from '../utils/installPackage.js';
 import { getPackageManager } from '../utils/packageManager.js';
 import { retrieveCredentials, setCredentials } from '../utils/credentials.js';
 import { areCredentialsSet } from '../utils/credentials.js';
+import localizeStaticUrls from '../utils/localizeStaticUrls.js';
+import flattenJsonFiles from '../utils/flattenJsonFiles.js';
 export class BaseCLI {
     library;
     additionalModules;
@@ -49,6 +51,9 @@ export class BaseCLI {
             .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('--dry-run', 'Dry run, does not send updates to General Translation API', false)
+            .option('--experimental-localize-static-urls', 'Triggering this will run a script after the cli tool that localizes all urls in content files. Currently only supported for md and mdx files.', false)
+            .option('--experimental-hide-default-locale', 'When localizing static locales, hide the default locale from the path', false)
+            .option('--experimental-flatten-json-files', 'Triggering this will flatten the json files into a single file. This is useful for projects that have a lot of json files.', false)
             .action(async (initOptions) => {
             displayHeader('Starting translation...');
             const settings = await generateSettings(initOptions);
@@ -172,6 +177,14 @@ See the docs for more information: https://generaltranslation.com/docs/react/tut
         const { resolvedPaths: sourceFiles, placeholderPaths, transformPaths, } = settings.files;
         // Process all file types at once with a single call
         await translateFiles(sourceFiles, placeholderPaths, transformPaths, dataFormat, settings);
+        // Localize static urls (/docs -> /[locale]/docs)
+        if (settings.experimentalLocalizeStaticUrls) {
+            await localizeStaticUrls(settings);
+        }
+        // Flatten json files into a single file
+        if (settings.experimentalFlattenJsonFiles) {
+            await flattenJsonFiles(settings);
+        }
     }
     async handleSetupReactCommand(options) {
         await handleSetupReactCommand(options);

package/dist/cli/react.js

@@ -16,8 +16,6 @@ import updateConfig from '../fs/config/updateConfig.js';
 import { validateConfigExists } from '../config/validateSettings.js';
 import { validateProject } from '../translation/validate.js';
 import { intro } from '@clack/prompts';
-import localizeStaticUrls from '../utils/localizeStaticUrls.js';
-import flattenJsonFiles from '../utils/flattenJsonFiles.js';
 const DEFAULT_TIMEOUT = 600;
 const pkg = 'gt-react';
 export class ReactCLI extends BaseCLI {
@@ -112,6 +110,7 @@ export class ReactCLI extends BaseCLI {
             .option('--default-language, --default-locale <locale>', 'Source locale (e.g., en)')
             .option('--inline', 'Include inline <T> tags in addition to dictionary file', true)
             .option('--ignore-errors', 'Ignore errors encountered while scanning for <T> tags', false)
+            .option('--suppress-warnings', 'Suppress warnings encountered while scanning for <T> tags', false)
             .option('-t, --translations-dir, --translation-dir <path>', 'Path to directory where translations will be saved. If this flag is not provided, translations will not be saved locally.')
             .action(async (options) => {
             displayHeader('Generating source templates...');
@@ -149,7 +148,18 @@ export class ReactCLI extends BaseCLI {
         }
         // User has to provide a dictionary file
         // will not read from settings.files.resolvedPaths.json
-        const { updates, errors } = await createUpdates(options, options.dictionary, this.library === 'gt-next' ? 'gt-next' : 'gt-react', false);
+        const { updates, errors, warnings } = await createUpdates(options, options.dictionary, this.library === 'gt-next' ? 'gt-next' : 'gt-react', false);
+        if (warnings.length > 0) {
+            if (options.suppressWarnings) {
+                logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To view these warnings, re-run without the --suppress-warnings flag')}`));
+            }
+            else {
+                logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To suppress these warnings, re-run with --suppress-warnings')}\n` +
+                    warnings
+                        .map((warning) => chalk.yellow('• Warning: ') + chalk.white(warning))
+                        .join('\n')));
+            }
+        }
         if (errors.length > 0) {
             if (options.ignoreErrors) {
                 logWarning(chalk.yellow(`CLI tool encountered errors while scanning for translatable content. These components will not be translated.\n` +
@@ -285,14 +295,6 @@ export class ReactCLI extends BaseCLI {
             }
             await translate(options, settings._versionId);
         }
-        // Localize static urls (/docs -> /[locale]/docs)
-        if (options.experimentalLocalizeStaticUrls) {
-            await localizeStaticUrls(options);
-        }
-        // Flatten json files into a single file
-        if (options.experimentalFlattenJsonFiles) {
-            await flattenJsonFiles(options);
-        }
     }
     async handleValidate(initOptions, files) {
         validateConfigExists();

package/dist/config/generateSettings.js

@@ -10,6 +10,7 @@ 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';
 export const DEFAULT_SRC_PATTERNS = [
     'src/**/*.{js,jsx,ts,tsx}',
     'app/**/*.{js,jsx,ts,tsx}',
@@ -101,5 +102,12 @@ export async function generateSettings(options, cwd = process.cwd()) {
         });
     }
     validateSettings(mergedOptions);
+    // Set up GT instance
+    gt.setConfig({
+        projectId: mergedOptions.projectId,
+        apiKey: mergedOptions.apiKey,
+        baseUrl: mergedOptions.baseUrl,
+        sourceLocale: mergedOptions.defaultLocale,
+    });
     return mergedOptions;
 }

package/dist/config/utils.d.ts

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

package/dist/config/utils.js

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

package/dist/formats/files/translate.js

@@ -182,7 +182,7 @@ async function processInitialTranslations(translations = [], fileMapping, option
         }
         // Use batch download if there are multiple files
         if (batchFiles.length > 1) {
-            const batchResult = await downloadFileBatch(options.baseUrl, options.projectId, options.apiKey, batchFiles.map(({ translationId, outputPath }) => ({
+            const batchResult = await downloadFileBatch(batchFiles.map(({ translationId, outputPath }) => ({
                 translationId,
                 outputPath,
             })));
@@ -200,7 +200,7 @@ async function processInitialTranslations(translations = [], fileMapping, option
         else if (batchFiles.length === 1) {
             // For a single file, use the original downloadFile method
             const file = batchFiles[0];
-            const result = await downloadFile(options.baseUrl, options.projectId, options.apiKey, file.translationId, file.outputPath);
+            const result = await downloadFile(file.translationId, file.outputPath);
             if (result) {
                 downloadStatus.downloaded.add(file.fileLocale);
             }

package/dist/formats/gt/save.d.ts

@@ -1,4 +1,4 @@
-import { RetrievedTranslations } from '../../types/api.js';
+import { RetrievedTranslations } from 'generaltranslation/types';
 import { ResolvedFiles } from '../../types/index.js';
 import { DataFormat } from '../../types/data.js';
 /**

package/dist/react/jsx/utils/parseJsx.d.ts

@@ -10,7 +10,7 @@ import * as t from '@babel/types';
  * @param insideT - Whether the current node is inside a <T> component
  * @returns The built JSX tree
  */
-export declare function buildJSXTree(importAliases: Record<string, string>, node: any, unwrappedExpressions: string[], updates: Updates, errors: string[], file: string, insideT: boolean): {
+export declare function buildJSXTree(importAliases: Record<string, string>, node: any, unwrappedExpressions: string[], updates: Updates, errors: string[], warnings: Set<string>, file: string, insideT: boolean): {
     expression?: boolean;
     result?: string;
     type?: string;
@@ -18,4 +18,4 @@ export declare function buildJSXTree(importAliases: Record<string, string>, node
         children?: any;
     };
 } | string | null;
-export declare function parseJSXElement(importAliases: Record<string, string>, node: t.JSXElement, updates: Updates, errors: string[], file: string): void;
+export declare function parseJSXElement(importAliases: Record<string, string>, node: t.JSXElement, updates: Updates, errors: string[], warnings: Set<string>, file: string): void;

package/dist/react/jsx/utils/parseJsx.js

@@ -18,7 +18,7 @@ import { GT_ATTRIBUTES, mapAttributeName, VARIABLE_COMPONENTS, } from './constan
  * @param insideT - Whether the current node is inside a <T> component
  * @returns The built JSX tree
  */
-export function buildJSXTree(importAliases, node, unwrappedExpressions, updates, errors, file, insideT) {
+export function buildJSXTree(importAliases, node, unwrappedExpressions, updates, errors, warnings, file, insideT) {
     if (t.isJSXExpressionContainer(node)) {
         // Skip JSX comments
         if (t.isJSXEmptyExpression(node.expression)) {
@@ -60,9 +60,8 @@ export function buildJSXTree(importAliases, node, unwrappedExpressions, updates,
         // Convert from alias to original name
         const componentType = importAliases[typeName ?? ''];
         if (componentType === 'T' && insideT) {
-            // Add error: No nested <T> components are allowed
-            errors.push(warnNestedTComponent(file, `${element.loc?.start?.line}:${element.loc?.start?.column}`));
-            return null;
+            // Add warning: Nested <T> components are allowed, but they are advised against
+            warnings.add(warnNestedTComponent(file, `${element.loc?.start?.line}:${element.loc?.start?.column}`));
         }
         // If this JSXElement is one of the recognized variable components,
         const elementIsVariable = VARIABLE_COMPONENTS.includes(componentType);
@@ -86,14 +85,14 @@ export function buildJSXTree(importAliases, node, unwrappedExpressions, updates,
                                 unwrappedExpressions.push(generate(attr.value).code);
                             }
                         }
-                        attrValue = buildJSXTree(importAliases, attr.value.expression, unwrappedExpressions, updates, errors, file, true);
+                        attrValue = buildJSXTree(importAliases, attr.value.expression, unwrappedExpressions, updates, errors, warnings, file, true);
                     }
                 }
                 props[attrName] = attrValue;
             }
         });
         if (elementIsVariable) {
-            parseJSXElement(importAliases, element, updates, errors, file);
+            parseJSXElement(importAliases, element, updates, errors, warnings, file);
             return {
                 // if componentType is undefined, use typeName
                 // Basically, if componentType is not a GT component, use typeName such as <div>
@@ -102,7 +101,7 @@ export function buildJSXTree(importAliases, node, unwrappedExpressions, updates,
             };
         }
         const children = element.children
-            .map((child) => buildJSXTree(importAliases, child, unwrappedExpressions, updates, errors, file, true))
+            .map((child) => buildJSXTree(importAliases, child, unwrappedExpressions, updates, errors, warnings, file, true))
             .filter((child) => child !== null && child !== '');
         if (children.length === 1) {
             props.children = children[0];
@@ -120,7 +119,7 @@ export function buildJSXTree(importAliases, node, unwrappedExpressions, updates,
     // If it's a JSX fragment
     else if (t.isJSXFragment(node)) {
         const children = node.children
-            .map((child) => buildJSXTree(importAliases, child, unwrappedExpressions, updates, errors, file, true))
+            .map((child) => buildJSXTree(importAliases, child, unwrappedExpressions, updates, errors, warnings, file, true))
             .filter((child) => child !== null && child !== '');
         const props = {};
         if (children.length === 1) {
@@ -153,7 +152,7 @@ export function buildJSXTree(importAliases, node, unwrappedExpressions, updates,
 }
 // end buildJSXTree
 // Parses a JSX element and adds it to the updates array
-export function parseJSXElement(importAliases, node, updates, errors, file) {
+export function parseJSXElement(importAliases, node, updates, errors, warnings, file) {
     const openingElement = node.openingElement;
     const name = openingElement.name;
     // Only proceed if it's <T> ...
@@ -161,6 +160,7 @@ export function parseJSXElement(importAliases, node, updates, errors, file) {
         return;
     }
     const componentErrors = [];
+    const componentWarnings = new Set();
     const metadata = {};
     // We'll track this flag to know if any unwrapped {variable} is found in children
     const unwrappedExpressions = [];
@@ -203,7 +203,7 @@ export function parseJSXElement(importAliases, node, updates, errors, file) {
         }
     });
     // Build the JSX tree for this component
-    const treeResult = buildJSXTree(importAliases, node, unwrappedExpressions, updates, componentErrors, file, false);
+    const treeResult = buildJSXTree(importAliases, node, unwrappedExpressions, updates, componentErrors, componentWarnings, file, false);
     let jsxTree = undefined;
     if (treeResult && typeof treeResult === 'object') {
         jsxTree = treeResult.props?.children;
@@ -211,6 +211,9 @@ export function parseJSXElement(importAliases, node, updates, errors, file) {
     else {
         jsxTree = treeResult;
     }
+    if (componentWarnings.size > 0) {
+        componentWarnings.forEach((warning) => warnings.add(warning));
+    }
     if (componentErrors.length > 0) {
         errors.push(...componentErrors);
         return;

package/dist/react/parse/createInlineUpdates.d.ts

@@ -2,4 +2,5 @@ import { Updates } from '../../types/index.js';
 export declare function createInlineUpdates(pkg: 'gt-react' | 'gt-next', validate: boolean, filePatterns: string[] | undefined): Promise<{
     updates: Updates;
     errors: string[];
+    warnings: string[];
 }>;

package/dist/react/parse/createInlineUpdates.js

@@ -14,6 +14,7 @@ import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
 export async function createInlineUpdates(pkg, validate, filePatterns) {
     const updates = [];
     const errors = [];
+    const warnings = new Set();
     // Use the provided app directory or default to the current directory
     const files = matchFiles(process.cwd(), filePatterns || DEFAULT_SRC_PATTERNS);
     for (const file of files) {
@@ -87,7 +88,7 @@ export async function createInlineUpdates(pkg, validate, filePatterns) {
         // Parse <T> components
         traverse(ast, {
             JSXElement(path) {
-                parseJSXElement(importAliases, path.node, updates, errors, file);
+                parseJSXElement(importAliases, path.node, updates, errors, warnings, file);
             },
         });
         // Extra validation (for Locadex)
@@ -109,5 +110,5 @@ export async function createInlineUpdates(pkg, validate, filePatterns) {
         });
         update.metadata.hash = hash;
     }));
-    return { updates, errors };
+    return { updates, errors, warnings: [...warnings] };
 }

package/dist/translation/parse.d.ts

@@ -11,4 +11,5 @@ import { Options, GenerateSourceOptions, Updates } from '../types/index.js';
 export declare function createUpdates(options: Options | GenerateSourceOptions, sourceDictionary: string | undefined, pkg: 'gt-react' | 'gt-next', validate: boolean): Promise<{
     updates: Updates;
     errors: string[];
+    warnings: string[];
 }>;

package/dist/translation/parse.js

@@ -17,6 +17,7 @@ import chalk from 'chalk';
 export async function createUpdates(options, sourceDictionary, pkg, validate) {
     let updates = [];
     let errors = [];
+    let warnings = [];
     // Parse dictionary with esbuildConfig
     if (sourceDictionary &&
         fs.existsSync(sourceDictionary) &&
@@ -48,8 +49,9 @@ export async function createUpdates(options, sourceDictionary, pkg, validate) {
     }
     // Scan through project for <T> tags
     if (options.inline) {
-        const { updates: newUpdates, errors: newErrors } = await createInlineUpdates(pkg, validate, options.src);
+        const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, options.src);
         errors = [...errors, ...newErrors];
+        warnings = [...warnings, ...newWarnings];
         updates = [...updates, ...newUpdates];
     }
     // Metadata addition and validation
@@ -72,5 +74,5 @@ export async function createUpdates(options, sourceDictionary, pkg, validate) {
     });
     // Filter out updates with duplicate IDs
     updates = updates.filter((update) => !duplicateIds.has(update.metadata.id));
-    return { updates, errors };
+    return { updates, errors, warnings };
 }

package/dist/translation/stage.js

@@ -26,7 +26,18 @@ export async function stageProject(settings, pkg) {
     }
     settings.timeout = timeout.toString();
     // ---- CREATING UPDATES ---- //
-    const { updates, errors } = await createUpdates(settings, settings.dictionary, pkg, false);
+    const { updates, errors, warnings } = await createUpdates(settings, settings.dictionary, pkg, false);
+    if (warnings.length > 0) {
+        if (settings.suppressWarnings) {
+            logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To view these warnings, re-run without the --suppress-warnings flag')}`));
+        }
+        else {
+            logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To suppress these warnings, re-run with --suppress-warnings')}\n` +
+                warnings
+                    .map((warning) => chalk.yellow('• Warning: ') + chalk.white(warning))
+                    .join('\n')));
+        }
+    }
     if (errors.length > 0) {
         if (settings.ignoreErrors) {
             logWarning(chalk.yellow(`Warning: CLI tool encountered ${errors.length} syntax errors while scanning for translatable content. These components will not be translated.\n` +

package/dist/translation/translate.js

@@ -6,11 +6,11 @@ export async function translate(settings, versionId) {
     // timeout was validated earlier
     const startTime = Date.now();
     const timeout = parseInt(settings.timeout) * 1000;
-    const result = await waitForUpdates(settings.projectId, settings.apiKey, settings.baseUrl, versionId, startTime, timeout);
+    const result = await waitForUpdates(versionId, startTime, timeout);
     if (!result) {
         process.exit(1);
     }
-    const translations = await fetchTranslations(settings.baseUrl, settings.projectId, settings.apiKey, versionId);
+    const translations = await fetchTranslations(versionId);
     // Save translations to local directory if files.gt.output is provided
     if (settings.files && isUsingLocalTranslations(settings)) {
         await saveTranslations(translations, settings.files.placeholderPaths, 'JSX');

package/dist/translation/validate.js

@@ -1,4 +1,4 @@
-import { logErrorAndExit } from '../console/logging.js';
+import { logErrorAndExit, logWarning } from '../console/logging.js';
 import chalk from 'chalk';
 import findFilepath from '../fs/findFilepath.js';
 import { logError, logSuccess } from '../console/logging.js';
@@ -27,7 +27,14 @@ export async function validateProject(settings, pkg, files) {
             './src/dictionary.ts',
         ]);
     }
-    const { updates, errors } = await createUpdates(settings, settings.dictionary, pkg, true);
+    const { updates, errors, warnings } = await createUpdates(settings, settings.dictionary, pkg, true);
+    if (warnings.length > 0) {
+        logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content.`) +
+            '\n' +
+            warnings
+                .map((warning) => chalk.yellow('• ') + chalk.white(warning))
+                .join('\n'));
+    }
     if (errors.length > 0) {
         logErrorAndExit(chalk.red(`Error: CLI tool encountered ${errors.length} syntax errors while scanning for translatable content.\n` +
             errors

package/dist/types/data.d.ts

@@ -17,8 +17,7 @@ export type JSONDictionary = {
 export type FlattenedJSONDictionary = {
     [key: string]: string;
 };
-export type DataFormat = 'JSX' | 'ICU' | 'I18NEXT';
-export type FileFormat = 'JSON' | 'YAML' | 'MDX' | 'MD' | 'TS' | 'JS';
+export type { FileFormat, DataFormat } from 'generaltranslation/types';
 export type JsxChildren = string | string[] | any;
 export type Translations = {
     [key: string]: JsxChildren;

package/dist/types/index.d.ts

@@ -1,17 +1,5 @@
-import { JsxChildren } from 'generaltranslation/internal';
 import { SUPPORTED_FILE_EXTENSIONS } from '../formats/files/supportedFiles.js';
-export type Updates = ({
-    metadata: Record<string, any>;
-} & ({
-    dataFormat: 'JSX';
-    source: JsxChildren;
-} | {
-    dataFormat: 'ICU';
-    source: string;
-} | {
-    dataFormat: 'I18NEXT';
-    source: string;
-}))[];
+export type { Updates } from 'generaltranslation/types';
 export type Options = {
     config: string;
     apiKey?: string;
@@ -25,6 +13,7 @@ export type Options = {
     baseUrl: string;
     inline?: boolean;
     ignoreErrors: boolean;
+    suppressWarnings: boolean;
     dryRun: boolean;
     timeout: string;
     stageTranslations?: boolean;
@@ -52,6 +41,7 @@ export type GenerateSourceOptions = {
     jsconfig?: string;
     inline?: boolean;
     ignoreErrors: boolean;
+    suppressWarnings: boolean;
 };
 export type Framework = 'gt-next' | 'gt-react';
 export type SupportedFrameworks = 'next-app' | 'next-pages' | 'vite' | 'gatsby' | 'react' | 'redwood';

package/dist/utils/flattenJsonFiles.d.ts

@@ -1,2 +1,2 @@
 import { Settings, Options } from '../types/index.js';
-export default function flattenJsonFiles(settings: Settings & Options): Promise<void>;
+export default function flattenJsonFiles(settings: Omit<Settings & Options, 'ignoreErrors' | 'suppressWarnings' | 'timeout'>): Promise<void>;

package/dist/utils/gt.d.ts

@@ -0,0 +1,2 @@
+import { GT } from 'generaltranslation';
+export declare const gt: GT;

package/dist/utils/gt.js

@@ -0,0 +1,2 @@
+import { GT } from 'generaltranslation';
+export const gt = new GT();

package/dist/utils/localizeStaticUrls.d.ts

@@ -12,4 +12,4 @@ import { Options, Settings } from '../types/index.js';
  * - Support more file types
  * - Support more complex paths
  */
-export default function localizeStaticUrls(settings: Settings & Options): Promise<void>;
+export default function localizeStaticUrls(settings: Omit<Settings & Options, 'ignoreErrors' | 'suppressWarnings' | 'timeout'>): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.0.5",
+  "version": "2.0.6-alpha.6",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -12,10 +12,10 @@
     "build": "tsc",
     "build:clean": "rm -rf dist; npm run build",
     "build:release": "npm run build:clean",
-    "lint": "eslint \"src/**/*.{js,ts}\" \"__tests__/**/*.{js,ts}\"",
-    "lint:fix": "eslint \"src/**/*.{js,ts}\" \"__tests__/**/*.{js,ts}\" --fix",
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "lint": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\"",
+    "lint:fix": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\" --fix",
+    "test": "vitest run --config=./vitest.config.ts",
+    "test:watch": "vitest --config=./vitest.config.ts",
     "release": "npm run build:clean && npm publish",
     "release:alpha": "npm run build:clean && npm publish --tag alpha",
     "release:beta": "npm run build:clean && npm publish --tag beta",
@@ -87,7 +87,7 @@
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.2",
-    "generaltranslation": "^7.0.1",
+    "generaltranslation": "^7.1.0-alpha.6",
     "open": "^10.1.1",
     "ora": "^8.2.0",
     "resolve": "^1.22.10",

package/dist/types/api.d.ts

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

package/dist/types/api.js

@@ -1 +0,0 @@
-export {};