gtx-cli 2.6.31 → 2.7.0

package/dist/formats/files/convertToFileTranslationData.d.ts

@@ -1,15 +0,0 @@
-import { FileToUpload } from 'generaltranslation/types';
-import { FileTranslationData } from '../../workflows/download.js';
-/**
- * Convert files to a file version data object
- * @param files - The files to get the version data for
- * @returns The version data for each file
- *
- * @example
- * const { allFiles } = await collectFiles(options, settings, library);
- * if (allFiles.length > 0) {
- *   const fileVersionData = getFileVersionData(allFiles);
- *   console.log(fileVersionData);
- * }
- */
-export declare function convertToFileTranslationData(files: FileToUpload[]): FileTranslationData;

package/dist/formats/files/convertToFileTranslationData.js

@@ -1,21 +0,0 @@
-/**
- * Convert files to a file version data object
- * @param files - The files to get the version data for
- * @returns The version data for each file
- *
- * @example
- * const { allFiles } = await collectFiles(options, settings, library);
- * if (allFiles.length > 0) {
- *   const fileVersionData = getFileVersionData(allFiles);
- *   console.log(fileVersionData);
- * }
- */
-export function convertToFileTranslationData(files) {
-    return Object.fromEntries(files.map((file) => [
-        file.fileId,
-        {
-            versionId: file.versionId,
-            fileName: file.fileName,
-        },
-    ]));
-}

package/dist/formats/files/fileMapping.d.ts

@@ -1,11 +0,0 @@
-import { ResolvedFiles, TransformFiles } from '../../types/index.js';
-import { FileMapping } from '../../types/files.js';
-/**
- * Creates a mapping between source files and their translated counterparts for each locale
- * @param filePaths - Resolved file paths for different file types
- * @param placeholderPaths - Placeholder paths for translated files
- * @param transformPaths - Transform paths for file naming
- * @param locales - List of locales to create a mapping for
- * @returns A mapping between source files and their translated counterparts for each locale, in the form of relative paths
- */
-export declare function createFileMapping(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, targetLocales: string[], defaultLocale: string): FileMapping;

package/dist/formats/files/fileMapping.js

@@ -1,115 +0,0 @@
-import { SUPPORTED_FILE_EXTENSIONS } from '../files/supportedFiles.js';
-import { resolveLocaleFiles } from '../../fs/config/parseFilesConfig.js';
-import path from 'node:path';
-import { getRelative } from '../../fs/findFilepath.js';
-import { getLocaleProperties } from 'generaltranslation';
-import { replaceLocalePlaceholders } from '../utils.js';
-import { TEMPLATE_FILE_NAME } from '../../utils/constants.js';
-/**
- * Creates a mapping between source files and their translated counterparts for each locale
- * @param filePaths - Resolved file paths for different file types
- * @param placeholderPaths - Placeholder paths for translated files
- * @param transformPaths - Transform paths for file naming
- * @param locales - List of locales to create a mapping for
- * @returns A mapping between source files and their translated counterparts for each locale, in the form of relative paths
- */
-export function createFileMapping(filePaths, placeholderPaths, transformPaths, targetLocales, defaultLocale) {
-    const fileMapping = {};
-    for (const locale of targetLocales) {
-        const translatedPaths = resolveLocaleFiles(placeholderPaths, locale);
-        const localeMapping = {};
-        // Process each file type
-        // Start with GTJSON Template files
-        if (translatedPaths.gt) {
-            const filepath = translatedPaths.gt;
-            localeMapping[TEMPLATE_FILE_NAME] = filepath;
-        }
-        for (const typeIndex of SUPPORTED_FILE_EXTENSIONS) {
-            if (!filePaths[typeIndex] || !translatedPaths[typeIndex])
-                continue;
-            const sourcePaths = filePaths[typeIndex];
-            let translatedFiles = translatedPaths[typeIndex];
-            if (!translatedFiles)
-                continue;
-            const transformPath = transformPaths[typeIndex];
-            if (transformPath) {
-                if (typeof transformPath === 'string') {
-                    translatedFiles = translatedFiles.map((filePath) => {
-                        const directory = path.dirname(filePath);
-                        const fileName = path.basename(filePath);
-                        const baseName = fileName.split('.')[0];
-                        const transformedFileName = transformPath
-                            .replace('*', baseName)
-                            .replace('[locale]', locale);
-                        return path.join(directory, transformedFileName);
-                    });
-                }
-                else if (Array.isArray(transformPath)) {
-                    // transformPath is an array of TransformOption objects
-                    const targetLocaleProperties = getLocaleProperties(locale);
-                    const defaultLocaleProperties = getLocaleProperties(defaultLocale);
-                    translatedFiles = translatedFiles.map((filePath) => {
-                        const relativePath = getRelative(filePath);
-                        // Try each transform in order until one matches
-                        for (const transform of transformPath) {
-                            if (!transform.replace || typeof transform.replace !== 'string') {
-                                continue;
-                            }
-                            // Replace all locale property placeholders in the replace string
-                            const replaceString = replaceLocalePlaceholders(transform.replace, targetLocaleProperties);
-                            if (transform.match && typeof transform.match === 'string') {
-                                // Replace locale placeholders in the match string using defaultLocale properties
-                                let matchString = transform.match;
-                                matchString = replaceLocalePlaceholders(matchString, defaultLocaleProperties);
-                                const regex = new RegExp(matchString);
-                                if (regex.test(relativePath)) {
-                                    // This transform matches, apply it and break
-                                    const transformedPath = relativePath.replace(new RegExp(matchString, 'g'), replaceString);
-                                    return path.resolve(transformedPath);
-                                }
-                            }
-                            else {
-                                // No match provided: treat as a direct replacement (override)
-                                return path.resolve(replaceString);
-                            }
-                        }
-                        // If no transforms matched, return the original path
-                        return filePath;
-                    });
-                }
-                else {
-                    // transformPath is an object
-                    const targetLocaleProperties = getLocaleProperties(locale);
-                    const defaultLocaleProperties = getLocaleProperties(defaultLocale);
-                    if (!transformPath.replace ||
-                        typeof transformPath.replace !== 'string') {
-                        continue;
-                    }
-                    // Replace all locale property placeholders
-                    const replaceString = replaceLocalePlaceholders(transformPath.replace, targetLocaleProperties);
-                    translatedFiles = translatedFiles.map((filePath) => {
-                        let relativePath = getRelative(filePath);
-                        if (transformPath.match &&
-                            typeof transformPath.match === 'string') {
-                            // Replace locale placeholders in the match string using defaultLocale properties
-                            let matchString = transformPath.match;
-                            matchString = replaceLocalePlaceholders(matchString, defaultLocaleProperties);
-                            relativePath = relativePath.replace(new RegExp(matchString, 'g'), replaceString);
-                        }
-                        else {
-                            relativePath = replaceString;
-                        }
-                        return path.resolve(relativePath);
-                    });
-                }
-            }
-            for (let i = 0; i < sourcePaths.length; i++) {
-                const sourceFile = getRelative(sourcePaths[i]);
-                const translatedFile = getRelative(translatedFiles[i]);
-                localeMapping[sourceFile] = translatedFile;
-            }
-        }
-        fileMapping[locale] = localeMapping;
-    }
-    return fileMapping;
-}

package/dist/formats/files/preprocess/mdx.d.ts

@@ -1,6 +0,0 @@
-import { Settings } from '../../../types/index.js';
-/**
- * Runs MDX-specific preprocessing. Returns a skip reason if the file
- * should be skipped, or null if validation passed.
- */
-export declare function preprocessMdx(content: string, filePath: string, settings: Settings): string | null;

package/dist/formats/files/preprocess/mdx.js

@@ -1,14 +0,0 @@
-import { isValidMdx } from '../../../utils/validateMdx.js';
-/**
- * Runs MDX-specific preprocessing. Returns a skip reason if the file
- * should be skipped, or null if validation passed.
- */
-export function preprocessMdx(content, filePath, settings) {
-    if (!settings.options?.skipFileValidation?.mdx) {
-        const validation = isValidMdx(content, filePath);
-        if (!validation.isValid) {
-            return `MDX file is not AST parsable${validation.error ? `: ${validation.error}` : ''}`;
-        }
-    }
-    return null;
-}

package/dist/formats/files/preprocess/mintlify.d.ts

@@ -1,5 +0,0 @@
-import { Settings } from '../../../types/index.js';
-/**
- * Runs all Mintlify-specific preprocessing on file content.
- */
-export declare function preprocessMintlify(content: string, filePath: string, fileType: string, settings: Settings): string;

package/dist/formats/files/preprocess/mintlify.js

@@ -1,15 +0,0 @@
-import { applyMintlifyTitleFallback } from '../../../utils/mintlifyTitleFallback.js';
-import wrapPlainUrls from '../../../utils/wrapPlainUrls.js';
-/**
- * Runs all Mintlify-specific preprocessing on file content.
- */
-export function preprocessMintlify(content, filePath, fileType, settings) {
-    if (fileType !== 'mdx')
-        return content;
-    let result = content;
-    if (settings.options?.mintlify?.inferTitleFromFilename) {
-        result = applyMintlifyTitleFallback(result, filePath, settings.defaultLocale).content;
-    }
-    result = wrapPlainUrls(result);
-    return result;
-}

package/dist/formats/files/preprocessContent.d.ts

@@ -1,8 +0,0 @@
-import { Settings } from '../../types/index.js';
-/**
- * Preprocesses file content before upload. Returns the processed content,
- * or { skip: reason } if the file should be skipped.
- */
-export declare function preprocessContent(content: string, filePath: string, fileType: string, settings: Settings): string | {
-    skip: string;
-};

package/dist/formats/files/preprocessContent.js

@@ -1,23 +0,0 @@
-import { preprocessMdx } from './preprocess/mdx.js';
-import { preprocessMintlify } from './preprocess/mintlify.js';
-import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
-/**
- * Preprocesses file content before upload. Returns the processed content,
- * or { skip: reason } if the file should be skipped.
- */
-export function preprocessContent(content, filePath, fileType, settings) {
-    let result = content;
-    // File-type-specific
-    if (fileType === 'mdx') {
-        const skipReason = preprocessMdx(result, filePath, settings);
-        if (skipReason)
-            return { skip: skipReason };
-    }
-    // Framework-specific
-    if (settings.framework === 'mintlify') {
-        result = preprocessMintlify(result, filePath, fileType, settings);
-    }
-    // Universal
-    result = sanitizeFileContent(result);
-    return result;
-}

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

@@ -1,5 +0,0 @@
-import { DataFormat } from '../../types/data.js';
-/**
- * Saves translated MDX/MD file content to the appropriate location
- */
-export declare function saveTranslatedFile(translatedContent: string, outputDir: string, fileName: string, dataFormat: DataFormat, locales: string[]): Promise<void>;

package/dist/formats/files/save.js

@@ -1,17 +0,0 @@
-import fs from 'fs/promises';
-import path from 'node:path';
-import { logger } from '../../console/logger.js';
-/**
- * Saves translated MDX/MD file content to the appropriate location
- */
-export async function saveTranslatedFile(translatedContent, outputDir, fileName, dataFormat, locales) {
-    // Create locale-specific directories if they don't exist
-    for (const locale of locales) {
-        const localeDir = path.join(outputDir, locale);
-        await fs.mkdir(localeDir, { recursive: true });
-        // Save the translated file with the appropriate extension
-        const outputPath = path.join(localeDir, fileName);
-        await fs.writeFile(outputPath, translatedContent);
-        logger.success(`Saved translated ${dataFormat} file to: ${outputPath}`);
-    }
-}

package/dist/formats/files/supportedFiles.d.ts

@@ -1,11 +0,0 @@
-export declare const SUPPORTED_FILE_EXTENSIONS: readonly ["json", "mdx", "md", "ts", "js", "yaml", "html", "txt"];
-export declare const FILE_EXT_TO_EXT_LABEL: {
-    json: string;
-    mdx: string;
-    md: string;
-    ts: string;
-    js: string;
-    yaml: string;
-    html: string;
-    txt: string;
-};

package/dist/formats/files/supportedFiles.js

@@ -1,20 +0,0 @@
-export const SUPPORTED_FILE_EXTENSIONS = [
-    'json',
-    'mdx',
-    'md',
-    'ts',
-    'js',
-    'yaml',
-    'html',
-    'txt',
-];
-export const FILE_EXT_TO_EXT_LABEL = {
-    json: 'JSON',
-    mdx: 'MDX',
-    md: 'Markdown',
-    ts: 'TypeScript',
-    js: 'JavaScript',
-    yaml: 'YAML',
-    html: 'HTML',
-    txt: 'Text',
-};

package/dist/formats/json/extractJson.d.ts

@@ -1,15 +0,0 @@
-import { AdditionalOptions } from '../../types/index.js';
-/**
- * Extracts translated values from a full JSON file back into composite JSON format.
- * This is the inverse of mergeJson - it takes a merged/reconstructed JSON file
- * and extracts the values for a specific locale into the composite structure
- * that the server expects.
- *
- * @param localContent - The full JSON content from the user's local file
- * @param inputPath - The path to the file (used for matching jsonSchema)
- * @param options - Additional options containing jsonSchema config
- * @param targetLocale - The locale to extract values for
- * @param defaultLocale - The default/source locale
- * @returns The composite JSON string, or null if no extraction needed
- */
-export declare function extractJson(localContent: string, inputPath: string, options: AdditionalOptions, targetLocale: string, defaultLocale: string): string | null;

package/dist/formats/json/extractJson.js

@@ -1,101 +0,0 @@
-import { logger } from '../../console/logger.js';
-import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, validateJsonSchema, } from './utils.js';
-import { flattenJsonWithStringFilter } from './flattenJson.js';
-import { gt } from '../../utils/gt.js';
-/**
- * Extracts translated values from a full JSON file back into composite JSON format.
- * This is the inverse of mergeJson - it takes a merged/reconstructed JSON file
- * and extracts the values for a specific locale into the composite structure
- * that the server expects.
- *
- * @param localContent - The full JSON content from the user's local file
- * @param inputPath - The path to the file (used for matching jsonSchema)
- * @param options - Additional options containing jsonSchema config
- * @param targetLocale - The locale to extract values for
- * @param defaultLocale - The default/source locale
- * @returns The composite JSON string, or null if no extraction needed
- */
-export function extractJson(localContent, inputPath, options, targetLocale, defaultLocale) {
-    const jsonSchema = validateJsonSchema(options, inputPath);
-    if (!jsonSchema) {
-        // No schema
-        return null;
-    }
-    let localJson;
-    try {
-        localJson = JSON.parse(localContent);
-    }
-    catch {
-        logger.error(`Invalid JSON file: ${inputPath}`);
-        return null;
-    }
-    const useCanonicalLocaleKeys = options?.experimentalCanonicalLocaleKeys ?? false;
-    const canonicalTargetLocale = useCanonicalLocaleKeys
-        ? gt.resolveCanonicalLocale(targetLocale)
-        : targetLocale;
-    const canonicalDefaultLocale = useCanonicalLocaleKeys
-        ? gt.resolveCanonicalLocale(defaultLocale)
-        : defaultLocale;
-    // Handle include-style schemas (simple path-based extraction)
-    if (jsonSchema.include) {
-        const extracted = flattenJsonWithStringFilter(localJson, jsonSchema.include);
-        return JSON.stringify(extracted, null, 2);
-    }
-    if (!jsonSchema.composite) {
-        logger.error('No include or composite property found in JSON schema');
-        return null;
-    }
-    // Handle composite schemas
-    const compositeResult = {};
-    // Generate source object pointers from the local JSON
-    const sourceObjectPointers = generateSourceObjectPointers(jsonSchema.composite, localJson);
-    for (const [sourceObjectPointer, { sourceObjectValue, sourceObjectOptions },] of Object.entries(sourceObjectPointers)) {
-        if (sourceObjectOptions.type === 'array') {
-            if (!Array.isArray(sourceObjectValue)) {
-                logger.warn(`Source object value is not an array at path: ${sourceObjectPointer}`);
-                continue;
-            }
-            // Find the matching items for the target locale
-            const matchingTargetLocaleItems = findMatchingItemArray(canonicalTargetLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-            if (!Object.keys(matchingTargetLocaleItems).length) {
-                logger.warn(`No matching items found for locale ${targetLocale} at path: ${sourceObjectPointer}`);
-                continue;
-            }
-            // Also find default locale items
-            const matchingDefaultLocaleItems = findMatchingItemArray(canonicalDefaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-            const defaultKeys = Object.keys(matchingDefaultLocaleItems);
-            const targetEntries = Object.entries(matchingTargetLocaleItems);
-            // Initialize the nested structure for this source object pointer
-            if (!compositeResult[sourceObjectPointer]) {
-                compositeResult[sourceObjectPointer] = {};
-            }
-            // For each target item, use the default locale's key position
-            for (let i = 0; i < targetEntries.length; i++) {
-                const [, { sourceItem }] = targetEntries[i];
-                // Extract values at the include paths
-                const extractedValues = flattenJsonWithStringFilter(sourceItem, sourceObjectOptions.include);
-                // Use default locale key
-                const outputKey = i < defaultKeys.length ? defaultKeys[i] : targetEntries[i][0];
-                compositeResult[sourceObjectPointer][outputKey] = extractedValues;
-            }
-        }
-        else {
-            // Object type
-            if (typeof sourceObjectValue !== 'object' || sourceObjectValue === null) {
-                logger.warn(`Source object value is not an object at path: ${sourceObjectPointer}`);
-                continue;
-            }
-            // Find the matching item for the target locale
-            const matchingTargetItem = findMatchingItemObject(canonicalTargetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
-            if (!matchingTargetItem.sourceItem) {
-                logger.warn(`No matching item found for locale ${targetLocale} at path: ${sourceObjectPointer}`);
-                continue;
-            }
-            // Extract values at the include paths
-            const extractedValues = flattenJsonWithStringFilter(matchingTargetItem.sourceItem, sourceObjectOptions.include);
-            // Store the extracted values
-            compositeResult[sourceObjectPointer] = extractedValues;
-        }
-    }
-    return JSON.stringify(compositeResult, null, 2);
-}

package/dist/formats/json/flattenJson.d.ts

@@ -1,14 +0,0 @@
-/**
- * Flattens a JSON object according to a list of JSON paths.
- * @param json - The JSON object to flatten
- * @param jsonPaths - The list of JSON paths to flatten
- * @returns A mapping of json pointers to their values
- */
-export declare function flattenJson(json: any, jsonPaths: string[]): Record<string, any>;
-/**
- * Flattens a JSON object according to a list of JSON paths, only including strings
- * @param json - The JSON object to flatten
- * @param jsonPaths - The list of JSON paths to flatten
- * @returns A mapping of json pointers to their values
- */
-export declare function flattenJsonWithStringFilter(json: any, jsonPaths: string[]): Record<string, any>;

package/dist/formats/json/flattenJson.js

@@ -1,64 +0,0 @@
-import { JSONPath } from 'jsonpath-plus';
-import { logger } from '../../console/logger.js';
-/**
- * Flattens a JSON object according to a list of JSON paths.
- * @param json - The JSON object to flatten
- * @param jsonPaths - The list of JSON paths to flatten
- * @returns A mapping of json pointers to their values
- */
-export function flattenJson(json, jsonPaths) {
-    const extractedJson = {};
-    for (const jsonPath of jsonPaths) {
-        try {
-            const results = JSONPath({
-                json,
-                path: jsonPath,
-                resultType: 'all',
-                flatten: true,
-                wrap: true,
-            });
-            if (!results || results.length === 0) {
-                continue;
-            }
-            results.forEach((result) => {
-                extractedJson[result.pointer] = result.value;
-            });
-        }
-        catch (error) {
-            logger.error(`Error with JSONPath pattern: ${jsonPath}`);
-        }
-    }
-    return extractedJson;
-}
-/**
- * Flattens a JSON object according to a list of JSON paths, only including strings
- * @param json - The JSON object to flatten
- * @param jsonPaths - The list of JSON paths to flatten
- * @returns A mapping of json pointers to their values
- */
-export function flattenJsonWithStringFilter(json, jsonPaths) {
-    const extractedJson = {};
-    for (const jsonPath of jsonPaths) {
-        try {
-            const results = JSONPath({
-                json,
-                path: jsonPath,
-                resultType: 'all',
-                flatten: true,
-                wrap: true,
-            });
-            if (!results || results.length === 0) {
-                continue;
-            }
-            results.forEach((result) => {
-                if (typeof result.value === 'string') {
-                    extractedJson[result.pointer] = result.value;
-                }
-            });
-        }
-        catch {
-            logger.error(`Error with JSONPath pattern: ${jsonPath}`);
-        }
-    }
-    return extractedJson;
-}

package/dist/formats/json/mergeJson.d.ts

@@ -1,13 +0,0 @@
-import { AdditionalOptions, SourceObjectOptions } from '../../types/index.js';
-export declare function mergeJson(originalContent: string, inputPath: string, options: AdditionalOptions, targets: {
-    translatedContent: string;
-    targetLocale: string;
-}[], defaultLocale: string, localeOrder?: string[]): string[];
-/**
- * Apply transformations to the sourceItem in-place
- * @param sourceItem - The source item to apply transformations to
- * @param transform - The transformations to apply
- * @param targetLocale - The target locale
- * @param defaultLocale - The default locale
- */
-export declare function applyTransformations(sourceItem: any, transform: SourceObjectOptions['transform'], targetLocale: string, defaultLocale: string): void;