gt 0.10.0 → 2.7.0

package/dist/formats/files/aggregateFiles.js

@@ -0,0 +1,156 @@
+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 { parseJson } from '../json/parseJson.js';
+import parseYaml from '../yaml/parseYaml.js';
+import YAML from 'yaml';
+import { determineLibrary } from '../../fs/determineFramework.js';
+import { hashStringSync } from '../../utils/hash.js';
+import { preprocessContent } from './preprocessContent.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);
+                const processed = preprocessContent(content, relativePath, fileType, settings);
+                if (typeof processed !== 'string') {
+                    logger.warn(`Skipping ${relativePath}: ${processed.skip}`);
+                    recordWarning('skipped_file', relativePath, processed.skip);
+                    return null;
+                }
+                return {
+                    content: processed,
+                    fileName: relativePath,
+                    fileFormat: fileType.toUpperCase(),
+                    fileId: hashStringSync(relativePath),
+                    versionId: hashStringSync(content),
+                    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

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

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

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

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

@@ -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,115 @@
+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

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

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

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

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

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

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

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

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

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

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

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

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