gtx-cli 2.3.6-alpha.2 → 2.3.6

package/dist/console/logging.js

@@ -0,0 +1,185 @@
+import { log, spinner, intro, outro, text, select, confirm, isCancel, cancel, multiselect, } from '@clack/prompts';
+import chalk from 'chalk';
+import { getCLIVersion } from '../utils/packageJson.js';
+// Basic logging functions
+export function logInfo(message) {
+    log.info(message);
+}
+export function logWarning(message) {
+    log.warn(message);
+}
+export function logError(message) {
+    log.error(message);
+}
+export function logSuccess(message) {
+    log.success(message);
+}
+export function logStep(message) {
+    log.step(message);
+}
+export function logMessage(message) {
+    log.message(message, { symbol: chalk.cyan('~') });
+}
+export function logErrorAndExit(message) {
+    log.error(message);
+    exit(1);
+}
+export function exit(code) {
+    process.exit(code);
+}
+// Clack prompts
+export function startCommand(message) {
+    intro(chalk.cyan(message));
+}
+export function endCommand(message) {
+    outro(chalk.cyan(message));
+}
+// GT specific logging
+export function displayHeader(introString) {
+    displayAsciiTitle();
+    displayInitializingText();
+    if (introString) {
+        startCommand(introString);
+    }
+}
+function displayAsciiTitle() {
+    console.log(chalk.cyan(`\n  ,ad8888ba,  888888888888  
+ d8"'    \`"8b      88       
+d8'                88       
+88                 88       
+88      88888      88       
+Y8,        88      88       
+ Y8a.    .a88      88       
+  \`"Y88888P"       88       `));
+}
+function displayInitializingText() {
+    const version = getCLIVersion();
+    console.log(`\n${chalk.bold.blue('General Translation, Inc.')}
+${chalk.dim('https://generaltranslation.com/docs')}
+${chalk.dim(`CLI Version: ${version}\n`)}`);
+}
+export function displayProjectId(projectId) {
+    logMessage(chalk.dim(`Project ID: ${chalk.bold(projectId)}`));
+}
+export function displayResolvedPaths(resolvedPaths) {
+    const paths = resolvedPaths.map(([key, resolvedPath]) => {
+        return chalk.dim(`'${chalk.white(key)}' → '${chalk.green(resolvedPath)}'`);
+    });
+    log.step(`Resolved path aliases:\n${paths.join('\n')}`);
+}
+export function displayCreatedConfigFile(configFilepath) {
+    log.step(`Created config file ${chalk.cyan(configFilepath)}`);
+}
+export function displayUpdatedConfigFile(configFilepath) {
+    log.success(`Updated config file ${chalk.cyan(configFilepath)}`);
+}
+export function displayUpdatedVersionsFile(versionFilepath) {
+    log.success(`Updated versions file ${chalk.cyan(versionFilepath)}`);
+}
+// Spinner functionality
+export function createSpinner(indicator = 'timer') {
+    return spinner({ indicator });
+}
+// Spinner functionality
+export async function createOraSpinner(indicator = 'circleHalves') {
+    const ora = await import('ora');
+    return ora.default({ spinner: indicator });
+}
+// Input prompts
+export async function promptText({ message, defaultValue, validate, }) {
+    const result = await text({
+        message,
+        placeholder: defaultValue,
+        validate: validate
+            ? (value) => {
+                const validation = validate(value || '');
+                return validation === true ? undefined : validation.toString();
+            }
+            : undefined,
+    });
+    if (isCancel(result)) {
+        cancel('Operation cancelled');
+        process.exit(0);
+    }
+    return result;
+}
+export async function promptSelect({ message, options, defaultValue, }) {
+    // Convert options to the format expected by clack
+    const clackOptions = options.map((opt) => ({
+        value: opt.value,
+        label: opt.label,
+        hint: opt.hint,
+    }));
+    const result = await select({
+        message,
+        options: clackOptions,
+        initialValue: defaultValue,
+    });
+    if (isCancel(result)) {
+        cancel('Operation cancelled');
+        process.exit(0);
+    }
+    return result;
+}
+export async function promptMultiSelect({ message, options, required = true, }) {
+    // Convert options to the format expected by clack
+    const clackOptions = options.map((opt) => ({
+        value: opt.value,
+        label: opt.label,
+        hint: opt.hint,
+    }));
+    const result = await multiselect({
+        message,
+        options: clackOptions,
+        required,
+    });
+    if (isCancel(result)) {
+        cancel('Operation cancelled');
+        process.exit(0);
+    }
+    return result;
+}
+export async function promptConfirm({ message, defaultValue = true, cancelMessage = 'Operation cancelled', }) {
+    const result = await confirm({
+        message,
+        initialValue: defaultValue,
+    });
+    if (isCancel(result)) {
+        cancel(cancelMessage);
+        process.exit(0);
+    }
+    return result;
+}
+// Warning display functions
+export function warnApiKeyInConfig(optionsFilepath) {
+    log.warn(`Found ${chalk.cyan('apiKey')} in "${chalk.green(optionsFilepath)}". ` +
+        chalk.white('Your API key is exposed! Please remove it from the file and include it as an environment variable.'));
+}
+export function warnVariableProp(file, attrName, value) {
+    log.warn(`Found ${chalk.green('<T>')} component in ${chalk.cyan(file)} with variable ${attrName}: "${chalk.white(value)}". ` +
+        `Change "${attrName}" to ensure this content is translated.`);
+}
+export function warnNoId(file) {
+    log.warn(`Found ${chalk.green('<T>')} component in ${chalk.cyan(file)} with no id. ` +
+        chalk.white('Add an id to ensure the content is translated.'));
+}
+export function warnHasUnwrappedExpression(file, id, unwrappedExpressions) {
+    log.warn(`${chalk.green('<T>')} with id "${id}" in ${chalk.cyan(file)} has children: ${unwrappedExpressions.join(', ')} that could change at runtime. ` +
+        chalk.white('Use a variable component like ') +
+        chalk.green('<Var>') +
+        chalk.white(' (') +
+        chalk.blue('https://generaltranslation.com/docs') +
+        chalk.white(') to translate this properly.'));
+}
+export function warnNonStaticExpression(file, attrName, value) {
+    log.warn(`Found non-static expression in ${chalk.cyan(file)} for attribute ${attrName}: "${chalk.white(value)}". ` +
+        `Change "${attrName}" to ensure this content is translated.`);
+}
+export function warnTemplateLiteral(file, value) {
+    log.warn(`Found template literal with quasis (${value}) in ${chalk.cyan(file)}. ` +
+        chalk.white('Change the template literal to a string to ensure this content is translated.'));
+}
+export function warnTernary(file) {
+    log.warn(`Found ternary expression in ${chalk.cyan(file)}. ` +
+        chalk.white('A Branch component may be more appropriate here.'));
+}

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,82 @@
+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 '../../cli/commands/stage.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 {
+                    // 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/save.d.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,17 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+import { logSuccess } from '../../console/logging.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);
+        logSuccess(`Saved translated ${dataFormat} file to: ${outputPath}`);
+    }
+}

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

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

package/dist/formats/files/supportedFiles.js

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

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

@@ -0,0 +1,4 @@
+import { Settings } from '../../types/index.js';
+import { FileToTranslate } from '../../types/data.js';
+export declare const SUPPORTED_DATA_FORMATS: string[];
+export declare function aggregateFiles(settings: Settings): Promise<FileToTranslate[]>;

package/dist/formats/files/translate.js

@@ -0,0 +1,119 @@
+import { logError, logWarning } from '../../console/logging.js';
+import { getRelative, readFile } from '../../fs/findFilepath.js';
+import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
+import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
+import { parseJson } from '../json/parseJson.js';
+import parseYaml from '../yaml/parseYaml.js';
+import { determineLibrary } from '../../fs/determineFramework.js';
+import { isValidMdx } from '../../utils/validateMdx.js';
+export const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
+export async function aggregateFiles(settings) {
+    // Aggregate all files to translate
+    const allFiles = [];
+    if (!settings.files ||
+        (Object.keys(settings.files.placeholderPaths).length === 1 &&
+            settings.files.placeholderPaths.gt)) {
+        return allFiles;
+    }
+    const { resolvedPaths: filePaths } = settings.files;
+    // Process JSON files
+    if (filePaths.json) {
+        const { library, additionalModules } = determineLibrary();
+        // Determine dataFormat for JSONs
+        let dataFormat;
+        if (library === 'next-intl') {
+            dataFormat = 'ICU';
+        }
+        else if (library === 'i18next') {
+            if (additionalModules.includes('i18next-icu')) {
+                dataFormat = 'ICU';
+            }
+            else {
+                dataFormat = 'I18NEXT';
+            }
+        }
+        else {
+            dataFormat = 'JSX';
+        }
+        const jsonFiles = filePaths.json
+            .map((filePath) => {
+            const content = readFile(filePath);
+            const relativePath = getRelative(filePath);
+            const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
+            return {
+                content: parsedJson,
+                fileName: relativePath,
+                fileFormat: 'JSON',
+                dataFormat,
+            };
+        })
+            .filter((file) => {
+            if (!file || typeof file.content !== 'string' || !file.content.trim()) {
+                logWarning(`Skipping ${file?.fileName ?? 'unknown'}: JSON file is empty`);
+                return false;
+            }
+            return true;
+        });
+        allFiles.push(...jsonFiles);
+    }
+    // Process YAML files
+    if (filePaths.yaml) {
+        const yamlFiles = filePaths.yaml
+            .map((filePath) => {
+            const content = readFile(filePath);
+            const relativePath = getRelative(filePath);
+            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, settings.options || {});
+            return {
+                content: parsedYaml,
+                fileName: relativePath,
+                fileFormat,
+            };
+        })
+            .filter((file) => {
+            if (!file || typeof file.content !== 'string' || !file.content.trim()) {
+                logWarning(`Skipping ${file?.fileName ?? 'unknown'}: YAML file is empty`);
+                return false;
+            }
+            return true;
+        });
+        allFiles.push(...yamlFiles);
+    }
+    for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
+        if (fileType === 'json' || fileType === 'yaml')
+            continue;
+        if (filePaths[fileType]) {
+            const files = filePaths[fileType]
+                .map((filePath) => {
+                const content = readFile(filePath);
+                const relativePath = getRelative(filePath);
+                if (fileType === 'mdx') {
+                    const validation = isValidMdx(content, filePath);
+                    if (!validation.isValid) {
+                        logWarning(`Skipping ${relativePath}: MDX file is not AST parsable${validation.error ? `: ${validation.error}` : ''}`);
+                        return null;
+                    }
+                }
+                const sanitizedContent = sanitizeFileContent(content);
+                return {
+                    content: sanitizedContent,
+                    fileName: relativePath,
+                    fileFormat: fileType.toUpperCase(),
+                };
+            })
+                .filter((file) => {
+                if (!file ||
+                    typeof file.content !== 'string' ||
+                    !file.content.trim()) {
+                    logWarning(`Skipping ${file?.fileName ?? 'unknown'}: File is empty after sanitization`);
+                    return false;
+                }
+                return true;
+            });
+            allFiles.push(...files);
+        }
+    }
+    if (allFiles.length === 0) {
+        logError('No files to translate were found. Please check your configuration and try again.');
+    }
+    return allFiles;
+}

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

@@ -0,0 +1,13 @@
+import { ResolvedFiles, Settings, TransformFiles } from '../../types/index.js';
+import { DataFormat } from '../../types/data.js';
+import { UploadOptions } from '../../cli/base.js';
+/**
+ * Sends multiple files to the API for translation
+ * @param filePaths - Resolved file paths for different file types
+ * @param placeholderPaths - Placeholder paths for translated files
+ * @param transformPaths - Transform paths for file naming
+ * @param dataFormat - Format of the data within the files
+ * @param options - Translation options including API settings
+ * @returns Promise that resolves when translation is complete
+ */
+export declare function upload(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, dataFormat: DataFormat | undefined, options: Settings & UploadOptions): Promise<void>;

package/dist/formats/files/upload.js

@@ -0,0 +1,136 @@
+import { noSupportedFormatError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, } from '../../console/index.js';
+import { logErrorAndExit, logError } from '../../console/logging.js';
+import { getRelative, readFile } from '../../fs/findFilepath.js';
+import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
+import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
+import { parseJson } from '../json/parseJson.js';
+import { uploadFiles } from '../../api/uploadFiles.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { createFileMapping } from './fileMapping.js';
+import parseYaml from '../yaml/parseYaml.js';
+const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
+/**
+ * Sends multiple files to the API for translation
+ * @param filePaths - Resolved file paths for different file types
+ * @param placeholderPaths - Placeholder paths for translated files
+ * @param transformPaths - Transform paths for file naming
+ * @param dataFormat - Format of the data within the files
+ * @param options - Translation options including API settings
+ * @returns Promise that resolves when translation is complete
+ */
+export async function upload(filePaths, placeholderPaths, transformPaths, dataFormat = 'JSX', options) {
+    // Collect all files to translate
+    const allFiles = [];
+    const additionalOptions = options.options || {};
+    // Process JSON files
+    if (filePaths.json) {
+        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
+            logErrorAndExit(noSupportedFormatError);
+        }
+        const jsonFiles = filePaths.json.map((filePath) => {
+            const content = readFile(filePath);
+            const parsedJson = parseJson(content, filePath, additionalOptions, options.defaultLocale);
+            const relativePath = getRelative(filePath);
+            return {
+                content: parsedJson,
+                fileName: relativePath,
+                fileFormat: 'JSON',
+                dataFormat,
+                locale: options.defaultLocale,
+            };
+        });
+        allFiles.push(...jsonFiles);
+    }
+    // Process YAML files
+    if (filePaths.yaml) {
+        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
+            logErrorAndExit(noSupportedFormatError);
+        }
+        const yamlFiles = filePaths.yaml.map((filePath) => {
+            const content = readFile(filePath);
+            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, additionalOptions);
+            const relativePath = getRelative(filePath);
+            return {
+                content: parsedYaml,
+                fileName: relativePath,
+                fileFormat,
+                dataFormat,
+                locale: options.defaultLocale,
+            };
+        });
+        allFiles.push(...yamlFiles);
+    }
+    for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
+        if (fileType === 'json' || fileType === 'yaml')
+            continue;
+        if (filePaths[fileType]) {
+            const files = filePaths[fileType].map((filePath) => {
+                const content = readFile(filePath);
+                const sanitizedContent = sanitizeFileContent(content);
+                const relativePath = getRelative(filePath);
+                return {
+                    content: sanitizedContent,
+                    fileName: relativePath,
+                    fileFormat: fileType.toUpperCase(),
+                    dataFormat,
+                    locale: options.defaultLocale,
+                };
+            });
+            allFiles.push(...files);
+        }
+    }
+    if (allFiles.length === 0) {
+        logError('No files to upload were found. Please check your configuration and try again.');
+        return;
+    }
+    if (!options.defaultLocale) {
+        logErrorAndExit(noDefaultLocaleError);
+    }
+    if (!options.apiKey) {
+        logErrorAndExit(noApiKeyError);
+    }
+    if (options.apiKey.startsWith('gtx-dev-')) {
+        logErrorAndExit(devApiKeyError);
+    }
+    if (!options.projectId) {
+        logErrorAndExit(noProjectIdError);
+    }
+    const locales = options.locales || [];
+    // Create file mapping for all file types
+    const fileMapping = createFileMapping(filePaths, placeholderPaths, transformPaths, locales, options.defaultLocale);
+    // construct object
+    const uploadData = allFiles.map((file) => {
+        const sourceFile = {
+            content: file.content,
+            fileName: file.fileName,
+            fileFormat: file.fileFormat,
+            dataFormat: file.dataFormat,
+            locale: file.locale,
+        };
+        const translations = [];
+        for (const locale of locales) {
+            const translatedFileName = fileMapping[locale][file.fileName];
+            if (translatedFileName && existsSync(translatedFileName)) {
+                const translatedContent = readFileSync(translatedFileName, 'utf8');
+                translations.push({
+                    content: translatedContent,
+                    fileName: translatedFileName,
+                    fileFormat: file.fileFormat,
+                    dataFormat: file.dataFormat,
+                    locale,
+                });
+            }
+        }
+        return {
+            source: sourceFile,
+            translations,
+        };
+    });
+    try {
+        // Send all files in a single API call
+        await uploadFiles(uploadData, options);
+    }
+    catch (error) {
+        logErrorAndExit(`Error uploading files: ${error}`);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { RetrievedTranslations } from 'generaltranslation/types';
+import { ResolvedFiles } from '../../types/index.js';
+/**
+ * Saves translations to a local directory
+ * @param translations - The translations to save
+ * @param translationsDir - The directory to save the translations to
+ * @param fileType - The file type to save the translations as (file extension)
+ */
+export declare function saveTranslations(translations: RetrievedTranslations, placeholderPaths: ResolvedFiles): Promise<void>;

package/dist/formats/gt/save.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logError } from '../../console/logging.js';
+import { noFilesError } from '../../console/index.js';
+import { resolveLocaleFiles } from '../../fs/config/parseFilesConfig.js';
+/**
+ * Saves translations to a local directory
+ * @param translations - The translations to save
+ * @param translationsDir - The directory to save the translations to
+ * @param fileType - The file type to save the translations as (file extension)
+ */
+export async function saveTranslations(translations, placeholderPaths) {
+    for (const translation of translations) {
+        const locale = translation.locale;
+        const translationFiles = resolveLocaleFiles(placeholderPaths, locale);
+        if (!translationFiles.gt) {
+            logError(noFilesError);
+            process.exit(1);
+        }
+        const filepath = translationFiles.gt;
+        const translationData = translation.translation;
+        // Ensure directory exists
+        await fs.promises.mkdir(path.dirname(filepath), { recursive: true });
+        await fs.promises.writeFile(filepath, JSON.stringify(translationData, null, 2));
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * 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>;