gtx-cli 2.3.5 → 2.3.6-alpha.1

package/dist/console/logging.js

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

@@ -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,82 +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 '../../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

@@ -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 { 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

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

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

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

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

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

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

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

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

@@ -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>;