gtx-cli 2.3.6-alpha.2 → 2.3.6

package/dist/translation/parse.js

@@ -0,0 +1,76 @@
+import fs from 'fs';
+import { logError } from '../console/logging.js';
+import loadJSON from '../fs/loadJSON.js';
+import { createDictionaryUpdates } from '../react/parse/createDictionaryUpdates.js';
+import { createInlineUpdates } from '../react/parse/createInlineUpdates.js';
+import createESBuildConfig from '../react/config/createESBuildConfig.js';
+import chalk from 'chalk';
+/**
+ * Searches for gt-react or gt-next dictionary files and creates updates for them,
+ * as well as inline updates for <T> tags and useGT()/getGT() calls
+ *
+ * @param options - The options object
+ * @param sourceDictionary - The source dictionary file path
+ * @param pkg - The package name
+ * @returns An object containing the updates and errors
+ */
+export async function createUpdates(options, src, sourceDictionary, pkg, validate) {
+    let updates = [];
+    let errors = [];
+    let warnings = [];
+    // Parse dictionary with esbuildConfig
+    if (sourceDictionary &&
+        fs.existsSync(sourceDictionary) &&
+        fs.statSync(sourceDictionary).isFile()) {
+        if (sourceDictionary.endsWith('.json')) {
+            updates = [
+                ...updates,
+                ...(await createDictionaryUpdates(sourceDictionary)),
+            ];
+        }
+        else {
+            let esbuildConfig;
+            if (options.jsconfig) {
+                const jsconfig = loadJSON(options.jsconfig);
+                if (!jsconfig) {
+                    logError(`Failed to resolve jsconfig.json or tsconfig.json at provided filepath: "${options.jsconfig}"`);
+                    process.exit(1);
+                }
+                esbuildConfig = createESBuildConfig(jsconfig);
+            }
+            else {
+                esbuildConfig = createESBuildConfig({});
+            }
+            updates = [
+                ...updates,
+                ...(await createDictionaryUpdates(sourceDictionary, esbuildConfig)),
+            ];
+        }
+    }
+    // Scan through project for <T> tags
+    const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, src);
+    errors = [...errors, ...newErrors];
+    warnings = [...warnings, ...newWarnings];
+    updates = [...updates, ...newUpdates];
+    // Metadata addition and validation
+    const idHashMap = new Map();
+    const duplicateIds = new Set();
+    updates = updates.map((update) => {
+        if (!update.metadata.id)
+            return update;
+        const existingHash = idHashMap.get(update.metadata.id);
+        if (existingHash) {
+            if (existingHash !== update.metadata.hash) {
+                errors.push(`Hashes don't match on two components with the same id: ${chalk.blue(update.metadata.id)}. Check your ${chalk.green('<T>')} tags and dictionary entries and make sure you're not accidentally duplicating IDs.`);
+                duplicateIds.add(update.metadata.id);
+            }
+        }
+        else {
+            idHashMap.set(update.metadata.id, update.metadata.hash);
+        }
+        return update;
+    });
+    // Filter out updates with duplicate IDs
+    updates = updates.filter((update) => !duplicateIds.has(update.metadata.id));
+    return { updates, errors, warnings };
+}

package/dist/translation/stage.d.ts

@@ -0,0 +1,2 @@
+import { Settings, TranslateFlags, Updates } from '../types/index.js';
+export declare function aggregateReactTranslations(options: TranslateFlags, settings: Settings, library: 'gt-react' | 'gt-next'): Promise<Updates>;

package/dist/translation/stage.js

@@ -0,0 +1,44 @@
+import { logErrorAndExit } from '../console/logging.js';
+import chalk from 'chalk';
+import findFilepath from '../fs/findFilepath.js';
+import { logWarning, logError } from '../console/logging.js';
+import { createUpdates } from './parse.js';
+export async function aggregateReactTranslations(options, settings, library) {
+    if (!options.dictionary) {
+        options.dictionary = findFilepath([
+            './dictionary.js',
+            './src/dictionary.js',
+            './dictionary.json',
+            './src/dictionary.json',
+            './dictionary.ts',
+            './src/dictionary.ts',
+        ]);
+    }
+    // ---- CREATING UPDATES ---- //
+    const { updates, errors, warnings } = await createUpdates(options, settings.src, options.dictionary, library, false);
+    if (warnings.length > 0) {
+        logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content.\n` +
+            warnings
+                .map((warning) => chalk.yellow('• Warning: ') + chalk.white(warning))
+                .join('\n')));
+    }
+    if (errors.length > 0) {
+        if (options.ignoreErrors) {
+            logWarning(chalk.yellow(`Warning: CLI tool encountered ${errors.length} syntax errors while scanning for translatable content. These components will not be translated.\n` +
+                errors
+                    .map((error) => chalk.yellow('• ') + chalk.white(error) + '\n')
+                    .join('')));
+        }
+        else {
+            logErrorAndExit(chalk.red(`Error: CLI tool encountered ${errors.length} syntax errors while scanning for translatable content. ${chalk.gray('To ignore these errors, re-run with --ignore-errors')}\n` +
+                errors
+                    .map((error) => chalk.red('• ') + chalk.white(error) + '\n')
+                    .join('')));
+        }
+    }
+    if (updates.length == 0) {
+        logError(chalk.red(`No in-line content or dictionaries were found for ${chalk.green(library)}. Are you sure you're running this command in the right directory?`));
+        return updates;
+    }
+    return updates;
+}

package/dist/translation/validate.d.ts

@@ -0,0 +1,2 @@
+import { Options, Settings } from '../types/index.js';
+export declare function validateProject(settings: Options & Settings, pkg: 'gt-react' | 'gt-next', files?: string[]): Promise<void>;

package/dist/translation/validate.js

@@ -0,0 +1,50 @@
+import { logErrorAndExit, logWarning } from '../console/logging.js';
+import chalk from 'chalk';
+import findFilepath from '../fs/findFilepath.js';
+import { logError, logSuccess } from '../console/logging.js';
+import { createUpdates } from './parse.js';
+import { createInlineUpdates } from '../react/parse/createInlineUpdates.js';
+export async function validateProject(settings, pkg, files) {
+    if (files && files.length > 0) {
+        // Validate specific files using createInlineUpdates
+        const { errors, updates } = await createInlineUpdates(pkg, true, files);
+        if (errors.length > 0) {
+            logErrorAndExit(chalk.red(`Error: CLI tool encountered ${errors.length} syntax errors:\n` +
+                errors
+                    .map((error) => chalk.red('• ') + chalk.white(error) + '\n')
+                    .join('')));
+        }
+        logSuccess(chalk.green(`Success! Found ${updates.length} translatable entries.`));
+        return;
+    }
+    if (!settings.dictionary) {
+        settings.dictionary = findFilepath([
+            './dictionary.js',
+            './src/dictionary.js',
+            './dictionary.json',
+            './src/dictionary.json',
+            './dictionary.ts',
+            './src/dictionary.ts',
+        ]);
+    }
+    const { updates, errors, warnings } = await createUpdates(settings, settings.src, 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
+                .map((error) => chalk.red('• ') + chalk.white(error) + '\n')
+                .join('')));
+    }
+    if (updates.length === 0) {
+        logError(chalk.red(`No in-line content or dictionaries were found for ${chalk.green(pkg)}. Are you sure you're running this command in the right directory?`));
+    }
+    else {
+        logSuccess(chalk.green(`Success! Found ${updates.length} translatable entries for ${chalk.green(pkg)}.`));
+    }
+}

package/dist/types/data/json.d.ts

@@ -0,0 +1,6 @@
+type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
+export type JSONObject = {
+    [key: string]: JSONValue;
+};
+export type JSONArray = JSONValue[];
+export {};

package/dist/types/data/json.js

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

package/dist/types/data.d.ts

@@ -0,0 +1,30 @@
+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 { FileFormat, DataFormat, FileToTranslate, } from 'generaltranslation/types';
+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 @@
+export {};

package/dist/types/files.d.ts

@@ -0,0 +1 @@
+export type FileMapping = Record<string, Record<string, string>>;

package/dist/types/files.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,173 @@
+import { CustomMapping } from 'generaltranslation/types';
+import { SUPPORTED_FILE_EXTENSIONS } from '../formats/files/supportedFiles.js';
+export type { Updates } from 'generaltranslation/types';
+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;
+    suppressWarnings: boolean;
+    dryRun: boolean;
+    timeout: number;
+    force?: boolean;
+    stageTranslations?: boolean;
+    experimentalLocalizeStaticUrls?: boolean;
+    experimentalHideDefaultLocale?: boolean;
+    experimentalFlattenJsonFiles?: boolean;
+    experimentalLocalizeStaticImports?: boolean;
+    experimentalAddHeaderAnchorIds?: 'mintlify';
+};
+export type TranslateFlags = {
+    config?: string;
+    apiKey?: string;
+    projectId?: string;
+    versionId?: string;
+    jsconfig?: string;
+    dictionary?: string;
+    defaultLocale?: string;
+    locales?: string[];
+    ignoreErrors?: boolean;
+    src?: string[];
+    timeout: number;
+    dryRun: boolean;
+    stageTranslations?: boolean;
+    publish?: boolean;
+    force?: boolean;
+    experimentalLocalizeStaticUrls?: boolean;
+    experimentalHideDefaultLocale?: boolean;
+    experimentalFlattenJsonFiles?: boolean;
+    experimentalLocalizeStaticImports?: boolean;
+    experimentalAddHeaderAnchorIds?: 'mintlify';
+    excludeStaticUrls?: string[];
+    excludeStaticImports?: string[];
+};
+export type WrapOptions = {
+    src?: string[];
+    config: string;
+    skipTs: boolean;
+    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;
+    suppressWarnings: 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 TransformOption = {
+    match?: string;
+    replace: string;
+};
+export type TransformFiles = {
+    [K in SupportedFileExtension]?: TransformOption | string;
+};
+export type FilesOptions = {
+    [K in SupportedFileExtension]?: {
+        include: string[];
+        exclude?: string[];
+        transform?: string | TransformOption;
+    };
+} & {
+    gt?: {
+        output: string;
+    };
+};
+export type Settings = {
+    config: string;
+    configDirectory: string;
+    baseUrl: string;
+    dashboardUrl: string;
+    apiKey?: string;
+    projectId?: string;
+    defaultLocale: string;
+    locales: string[];
+    customMapping?: CustomMapping;
+    files: {
+        resolvedPaths: ResolvedFiles;
+        placeholderPaths: ResolvedFiles;
+        transformPaths: TransformFiles;
+    } | undefined;
+    stageTranslations: boolean;
+    publish: boolean;
+    _versionId?: string;
+    version?: string;
+    description?: string;
+    src: string[];
+    framework?: SupportedFrameworks;
+    options?: AdditionalOptions;
+    modelProvider?: string;
+};
+export type AdditionalOptions = {
+    jsonSchema?: {
+        [fileGlob: string]: JsonSchema;
+    };
+    yamlSchema?: {
+        [fileGlob: string]: YamlSchema;
+    };
+    docsUrlPattern?: string;
+    docsImportPattern?: string;
+    excludeStaticUrls?: string[];
+    excludeStaticImports?: string[];
+    docsHideDefaultLocaleImport?: boolean;
+    copyFiles?: string[];
+    experimentalLocalizeStaticImports?: boolean;
+    experimentalLocalizeStaticUrls?: boolean;
+    experimentalAddHeaderAnchorIds?: 'mintlify';
+    experimentalHideDefaultLocale?: boolean;
+    experimentalFlattenJsonFiles?: boolean;
+    baseDomain?: string;
+};
+export type JsonSchema = {
+    preset?: 'mintlify';
+    include?: string[];
+    composite?: {
+        [sourceObjectPath: string]: SourceObjectOptions;
+    };
+};
+export type YamlSchema = {
+    preset?: 'mintlify';
+    include?: string[];
+};
+export type SourceObjectOptions = {
+    type: 'array' | 'object';
+    include: string[];
+    key?: string;
+    localeProperty?: string;
+    transform?: TransformOptions;
+};
+export type TransformOptions = {
+    [transformPath: string]: TransformOption;
+};

package/dist/types/index.js

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

package/dist/utils/addExplicitAnchorIds.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Represents a heading with its position and metadata
+ */
+export interface HeadingInfo {
+    text: string;
+    level: number;
+    slug: string;
+    position: number;
+}
+/**
+ * Extracts heading information from content (read-only, no modifications)
+ */
+export declare function extractHeadingInfo(mdxContent: string): HeadingInfo[];
+/**
+ * Applies anchor IDs to translated content based on source heading mapping
+ */
+export declare function addExplicitAnchorIds(translatedContent: string, sourceHeadingMap: HeadingInfo[], settings?: any, sourcePath?: string, translatedPath?: string): {
+    content: string;
+    hasChanges: boolean;
+    addedIds: Array<{
+        heading: string;
+        id: string;
+    }>;
+};