gtx-cli 2.6.29 → 2.6.30-alpha.0

package/dist/formats/files/aggregateFiles.js

@@ -1,173 +0,0 @@
-import { logger } from '../../console/logger.js';
-import { recordWarning } from '../../state/translateWarnings.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 YAML from 'yaml';
-import { determineLibrary } from '../../fs/determineFramework.js';
-import { isValidMdx } from '../../utils/validateMdx.js';
-import { hashStringSync } from '../../utils/hash.js';
-import { applyMintlifyTitleFallback } from '../../utils/mintlifyTitleFallback.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;
-    const skipValidation = settings.options?.skipFileValidation;
-    // 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 = 'STRING';
-        }
-        const jsonFiles = filePaths.json
-            .map((filePath) => {
-            const content = readFile(filePath);
-            const relativePath = getRelative(filePath);
-            // Pre-validate JSON parseability
-            if (!skipValidation?.json) {
-                try {
-                    JSON.parse(content);
-                }
-                catch (e) {
-                    logger.warn(`Skipping ${relativePath}: JSON file is not parsable`);
-                    recordWarning('skipped_file', relativePath, 'JSON file is not parsable');
-                    return null;
-                }
-            }
-            const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
-            return {
-                fileId: hashStringSync(relativePath),
-                versionId: hashStringSync(parsedJson),
-                content: parsedJson,
-                fileName: relativePath,
-                fileFormat: 'JSON',
-                dataFormat,
-                locale: settings.defaultLocale,
-            };
-        })
-            .filter((file) => {
-            if (!file)
-                return false;
-            if (typeof file.content !== 'string' || !file.content.trim()) {
-                logger.warn(`Skipping ${file.fileName}: JSON file is empty`);
-                recordWarning('skipped_file', file.fileName, 'JSON file is empty');
-                return false;
-            }
-            return true;
-        });
-        allFiles.push(...jsonFiles.filter((file) => file !== null));
-    }
-    // Process YAML files
-    if (filePaths.yaml) {
-        const yamlFiles = filePaths.yaml
-            .map((filePath) => {
-            const content = readFile(filePath);
-            const relativePath = getRelative(filePath);
-            // Pre-validate YAML parseability
-            if (!skipValidation?.yaml) {
-                try {
-                    YAML.parse(content);
-                }
-                catch (e) {
-                    logger.warn(`Skipping ${relativePath}: YAML file is not parsable`);
-                    recordWarning('skipped_file', relativePath, 'YAML file is not parsable');
-                    return null;
-                }
-            }
-            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, settings.options || {});
-            return {
-                content: parsedYaml,
-                fileName: relativePath,
-                fileFormat,
-                fileId: hashStringSync(relativePath),
-                versionId: hashStringSync(parsedYaml),
-                locale: settings.defaultLocale,
-            };
-        })
-            .filter((file) => {
-            if (!file || typeof file.content !== 'string' || !file.content.trim()) {
-                logger.warn(`Skipping ${file?.fileName ?? 'unknown'}: YAML file is empty`);
-                recordWarning('skipped_file', file?.fileName ?? 'unknown', 'YAML file is empty');
-                return false;
-            }
-            return true;
-        });
-        allFiles.push(...yamlFiles.filter((file) => file !== null));
-    }
-    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') {
-                    if (!skipValidation?.mdx) {
-                        const validation = isValidMdx(content, filePath);
-                        if (!validation.isValid) {
-                            logger.warn(`Skipping ${relativePath}: MDX file is not AST parsable${validation.error ? `: ${validation.error}` : ''}`);
-                            recordWarning('skipped_file', relativePath, `MDX file is not AST parsable${validation.error ? `: ${validation.error}` : ''}`);
-                            return null;
-                        }
-                    }
-                }
-                let processedContent = content;
-                let addedMintlifyTitle = false;
-                if (fileType === 'mdx' &&
-                    settings.options?.mintlify?.inferTitleFromFilename) {
-                    const result = applyMintlifyTitleFallback(processedContent, relativePath, settings.defaultLocale);
-                    processedContent = result.content;
-                    addedMintlifyTitle = result.addedTitle;
-                }
-                const sanitizedContent = sanitizeFileContent(processedContent);
-                // Always hash original content for versionId
-                const computedVersionId = hashStringSync(content);
-                return {
-                    content: sanitizedContent,
-                    fileName: relativePath,
-                    fileFormat: fileType.toUpperCase(),
-                    fileId: hashStringSync(relativePath),
-                    versionId: computedVersionId,
-                    locale: settings.defaultLocale,
-                };
-            })
-                .filter((file) => {
-                if (!file ||
-                    typeof file.content !== 'string' ||
-                    !file.content.trim()) {
-                    logger.warn(`Skipping ${file?.fileName ?? 'unknown'}: File is empty after sanitization`);
-                    recordWarning('skipped_file', file?.fileName ?? 'unknown', 'File is empty after sanitization');
-                    return false;
-                }
-                return true;
-            });
-            allFiles.push(...files.filter((file) => file !== null));
-        }
-    }
-    if (allFiles.length === 0 && !settings.publish) {
-        logger.error('No files to translate were found. Please check your configuration and try again.');
-    }
-    return allFiles;
-}

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

@@ -1,6 +0,0 @@
-import { Settings, SupportedLibraries, TranslateFlags } from '../../types/index.js';
-import type { FileToUpload } from 'generaltranslation/types';
-export declare function collectFiles(options: TranslateFlags, settings: Settings, library: SupportedLibraries): Promise<{
-    files: FileToUpload[];
-    reactComponents: number;
-}>;

package/dist/formats/files/collectFiles.js

@@ -1,49 +0,0 @@
-import { logErrorAndExit } from '../../console/logging.js';
-import { invalidConfigurationError } from '../../console/index.js';
-import { aggregateFiles } from './aggregateFiles.js';
-import { aggregateInlineTranslations } from '../../translation/stage.js';
-import { hashStringSync } from '../../utils/hash.js';
-import { TEMPLATE_FILE_NAME, TEMPLATE_FILE_ID } from '../../utils/constants.js';
-import { isInlineLibrary } from '../../types/libraries.js';
-export async function collectFiles(options, settings, library) {
-    // Aggregate files
-    const allFiles = await aggregateFiles(settings);
-    // Parse for React components
-    let reactComponents = 0;
-    if (isInlineLibrary(library)) {
-        const updates = await aggregateInlineTranslations(options, settings, library);
-        if (updates.length > 0) {
-            if (!settings.publish && !settings.files?.placeholderPaths.gt) {
-                logErrorAndExit(invalidConfigurationError);
-            }
-            // Convert updates to a file object
-            const fileData = {};
-            const fileMetadata = {};
-            // Convert updates to the proper data format
-            for (const update of updates) {
-                const { source, metadata, dataFormat } = update;
-                metadata.dataFormat = dataFormat; // add the data format to the metadata
-                const { hash, id } = metadata;
-                if (id) {
-                    fileData[id] = source;
-                    fileMetadata[id] = metadata;
-                }
-                else {
-                    fileData[hash] = source;
-                    fileMetadata[hash] = metadata;
-                }
-            }
-            reactComponents = updates.length;
-            allFiles.push({
-                fileName: TEMPLATE_FILE_NAME,
-                content: JSON.stringify(fileData),
-                fileFormat: 'GTJSON',
-                formatMetadata: fileMetadata,
-                fileId: TEMPLATE_FILE_ID,
-                versionId: hashStringSync(JSON.stringify(Object.keys(fileData).sort())),
-                locale: settings.defaultLocale,
-            });
-        }
-    }
-    return { files: allFiles, reactComponents };
-}

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/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;
-}