gt 2.14.35 → 2.14.36

package/dist/formats/json/mergeJson.js

@@ -1,376 +1,235 @@
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, getIdentifyingLocaleProperty, getSourceObjectOptionsArray, validateJsonSchema, } from './utils.js';
-import { getLocaleProperties } from '@generaltranslation/format';
-import { replaceLocalePlaceholders } from '../utils.js';
-import { gt } from '../../utils/gt.js';
-import { applyStructuralTransforms, unapplyStructuralTransforms, } from './transformJson.js';
-import { getJSONPathMatches, getJSONPathValues } from './jsonPath.js';
-import { getJSONPointerValue, setJSONPointerValue } from './jsonPointer.js';
-export function mergeJson(originalContent, inputPath, options, targets, defaultLocale, localeOrder = []) {
-    const jsonSchema = validateJsonSchema(options, inputPath);
-    if (!jsonSchema) {
-        return targets.map((target) => target.translatedContent);
-    }
-    let originalJson;
-    try {
-        originalJson = JSON.parse(originalContent);
-    }
-    catch {
-        logger.error(`Invalid JSON file: ${inputPath}`);
-        return exitSync(1);
-    }
-    const useCanonicalLocaleKeys = options?.experimentalCanonicalLocaleKeys ?? false;
-    const canonicalDefaultLocale = useCanonicalLocaleKeys
-        ? gt.resolveCanonicalLocale(defaultLocale)
-        : defaultLocale;
-    const canonicalLocaleOrder = useCanonicalLocaleKeys
-        ? localeOrder.map((locale) => gt.resolveCanonicalLocale(locale))
-        : localeOrder;
-    if (jsonSchema.structuralTransform && jsonSchema.composite) {
-        applyStructuralTransforms(originalJson, jsonSchema.structuralTransform, jsonSchema.composite);
-    }
-    // Handle include
-    if (jsonSchema.include) {
-        const output = [];
-        for (const target of targets) {
-            // Must clone the original JSON to avoid mutations
-            const mergedJson = structuredClone(originalJson);
-            const translatedJson = JSON.parse(target.translatedContent);
-            for (const [jsonPointer, translatedValue] of Object.entries(translatedJson)) {
-                try {
-                    const value = getJSONPointerValue(mergedJson, jsonPointer);
-                    if (!value)
-                        continue;
-                    setJSONPointerValue(mergedJson, jsonPointer, translatedValue);
-                }
-                catch {
-                    /* empty */
-                }
-            }
-            output.push(JSON.stringify(mergedJson, null, 2));
-        }
-        return output;
-    }
-    if (!jsonSchema.composite) {
-        logger.error('No composite property found in JSON schema');
-        return exitSync(1);
-    }
-    // Handle composite
-    // Create a deep copy of the original JSON to avoid mutations
-    const mergedJson = structuredClone(originalJson);
-    // Pre-parse all target contents ONCE (avoid re-parsing per pointer)
-    const parsedTargets = targets.map((target) => ({
-        ...target,
-        parsedContent: JSON.parse(target.translatedContent),
-    }));
-    // Create mapping of sourceObjectPointer to SourceObjectOptions
-    const sourceObjectPointers = generateSourceObjectPointers(jsonSchema.composite, originalJson);
-    // Find the source object
-    for (const [sourceObjectPointer, { sourceObjectValue, sourceObjectOptions },] of Object.entries(sourceObjectPointers)) {
-        // Find the source item
-        if (sourceObjectOptions.type === 'array') {
-            // Validate type
-            if (!Array.isArray(sourceObjectValue)) {
-                logger.error(`Source object value is not an array at path: ${sourceObjectPointer}`);
-                return exitSync(1);
-            }
-            // Get source item for default locale
-            const matchingDefaultLocaleItems = findMatchingItemArray(canonicalDefaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-            if (!Object.keys(matchingDefaultLocaleItems).length) {
-                logger.warn(`Matching sourceItems not found at path: ${sourceObjectPointer}. Check that your JSON file includes the key field. Skipping this target`);
-                continue;
-            }
-            const matchingDefaultLocaleItemKeys = new Set(Object.keys(matchingDefaultLocaleItems));
-            // For each target:
-            // 1. Get the target items
-            // 2. Track all array indecies to remove (will be overwritten)
-            // 3. Merge matchingDefaultLocaleItems and targetItems
-            // 4. Validate that the mergedItems is not empty
-            // For each target item:
-            //   5. Validate that all the array indecies are still present in the source json
-            //   6. Override the source item with the translated values
-            //   7. Apply additional mutations to the sourceItem
-            //   8. Track all items to add
-            // 9. Check that items to add is >= items to remove
-            // 10. Remove all items for the target locale (they can be identified by the key)
-            const indiciesToRemove = new Set();
-            const itemsToAdd = [];
-            for (const target of parsedTargets) {
-                let targetItems = target.parsedContent[sourceObjectPointer];
-                // 1. Get the target items
-                if (!targetItems) {
-                    // If no translation can be found, a transformation may need to happen still
-                    targetItems = {};
-                }
-                // 2. Track all array indecies to remove (will be overwritten)
-                const targetItemsToRemove = findMatchingItemArray(useCanonicalLocaleKeys
-                    ? gt.resolveCanonicalLocale(target.targetLocale)
-                    : target.targetLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-                Object.values(targetItemsToRemove).forEach(({ index }) => indiciesToRemove.add(index));
-                // Remap mismatched positional keys to current source positions
-                const sourceKeys = [...matchingDefaultLocaleItemKeys];
-                const remappedTargetItems = {};
-                for (const [key, value] of Object.entries(targetItems)) {
-                    if (matchingDefaultLocaleItemKeys.has(key)) {
-                        remappedTargetItems[key] = value;
-                    }
-                    else if (sourceKeys.length === 1 &&
-                        !(sourceKeys[0] in remappedTargetItems)) {
-                        remappedTargetItems[sourceKeys[0]] = value;
-                    }
-                    else {
-                        logger.warn(`Skipping translated item at ${key}: cannot map to source item at path ${sourceObjectPointer}`);
-                    }
-                }
-                // Merge matchingDefaultLocaleItems and remapped targetItems
-                const mergedItems = {
-                    ...(sourceObjectOptions.transform ? matchingDefaultLocaleItems : {}),
-                    ...remappedTargetItems,
-                };
-                // 4. Validate that the mergedItems is not empty
-                if (Object.keys(mergedItems).length === 0) {
-                    logger.warn(`Translated JSON for locale: ${target.targetLocale} does not have a valid sourceObjectPointer: ${sourceObjectPointer}. Skipping this target`);
-                    continue;
-                }
-                for (const [sourceItemPointer, targetItem] of Object.entries(mergedItems)) {
-                    // 5. Validate that all the array indecies are still present in the source json
-                    if (!matchingDefaultLocaleItemKeys.has(sourceItemPointer)) {
-                        logger.warn(`Skipping translated item at ${sourceItemPointer}: not present in source json at path ${sourceObjectPointer}`);
-                        continue;
-                    }
-                    // 6. Override the source item with the translated values
-                    const defaultLocaleSourceItem = matchingDefaultLocaleItems[sourceItemPointer].sourceItem;
-                    const defaultLocaleKeyPointer = matchingDefaultLocaleItems[sourceItemPointer].keyPointer;
-                    const mutatedSourceItem = structuredClone(defaultLocaleSourceItem);
-                    const { identifyingLocaleProperty: targetLocaleKeyProperty } = getSourceObjectOptionsArray(useCanonicalLocaleKeys
-                        ? gt.resolveCanonicalLocale(target.targetLocale)
-                        : target.targetLocale, sourceObjectPointer, sourceObjectOptions);
-                    setJSONPointerValue(mutatedSourceItem, defaultLocaleKeyPointer, targetLocaleKeyProperty);
-                    for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries((targetItem || {}))) {
-                        const valueToSet = useCanonicalLocaleKeys &&
-                            defaultLocaleKeyPointer &&
-                            translatedKeyJsonPointer === defaultLocaleKeyPointer
-                            ? targetLocaleKeyProperty
-                            : translatedValue;
-                        try {
-                            const value = getJSONPointerValue(mutatedSourceItem, translatedKeyJsonPointer);
-                            if (!value)
-                                continue;
-                            setJSONPointerValue(mutatedSourceItem, translatedKeyJsonPointer, valueToSet);
-                        }
-                        catch {
-                            /* empty */
-                        }
-                    }
-                    // 7. Apply additional mutations to the sourceItem
-                    applyTransformations(mutatedSourceItem, sourceObjectOptions.transform, target.targetLocale, defaultLocale);
-                    itemsToAdd.push(mutatedSourceItem);
-                }
-            }
-            // 8. Check that items to add is >= items to remove
-            if (itemsToAdd.length < indiciesToRemove.size) {
-                logger.warn(`Items to add (${itemsToAdd.length}) is less than items to remove (${indiciesToRemove.size}) at path: ${sourceObjectPointer}. Some translated items may have been skipped.`);
-            }
-            // 9. Remove all items for the target locale (they can be identified by the key)
-            const filteredSourceObjectValue = sourceObjectValue.filter((_, index) => !indiciesToRemove.has(index));
-            // 10. Add all items to the original JSON
-            filteredSourceObjectValue.push(...itemsToAdd);
-            setJSONPointerValue(mergedJson, sourceObjectPointer, sortByLocaleOrder(filteredSourceObjectValue, sourceObjectOptions, canonicalLocaleOrder, sourceObjectPointer, canonicalDefaultLocale));
-        }
-        else {
-            // Validate type
-            if (typeof sourceObjectValue !== 'object' || sourceObjectValue === null) {
-                logger.error(`Source object value is not an object at path: ${sourceObjectPointer}`);
-                return exitSync(1);
-            }
-            const sourceObjectRecord = sourceObjectValue;
-            // Validate localeProperty
-            const matchingDefaultLocaleItem = findMatchingItemObject(canonicalDefaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectRecord);
-            // Validate source item exists
-            if (!matchingDefaultLocaleItem.sourceItem) {
-                logger.error(`Source item not found at path: ${sourceObjectPointer}. You must specify a source item where its key matches the default locale`);
-                return exitSync(1);
-            }
-            const { sourceItem: defaultLocaleSourceItem } = matchingDefaultLocaleItem;
-            // For each target:
-            // 1. Get the target items
-            // 2. Find the source item for the target locale
-            // 3. Merge the target items with the source item
-            // 4. Validate that the mergedItems is not empty
-            // 5. Override the source item with the translated values
-            // 6. Apply additional mutations to the sourceItem
-            // 7. Merge the source item with the original JSON (if the source item is not a new item)
-            for (const target of parsedTargets) {
-                // 1. Get the target items
-                let targetItems = target.parsedContent[sourceObjectPointer];
-                if (targetItems == null) {
-                    targetItems = {};
-                }
-                // 2. Find the source item for the target locale
-                const matchingTargetItem = findMatchingItemObject(useCanonicalLocaleKeys
-                    ? gt.resolveCanonicalLocale(target.targetLocale)
-                    : target.targetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectRecord);
-                const mutateSourceItemKey = matchingTargetItem.keyParentProperty;
-                // If the source item is a string, use the translated string directly
-                if (typeof defaultLocaleSourceItem === 'string') {
-                    if (typeof targetItems === 'string') {
-                        sourceObjectRecord[mutateSourceItemKey] = targetItems;
-                    }
-                    // If no translation found, leave the locale slot unchanged
-                    continue;
-                }
-                // If the target locale has a matching source item, use it to mutate the source item
-                // Otherwise, fallback to the default locale source item
-                const mutateSourceItem = structuredClone(defaultLocaleSourceItem);
-                // 3. Merge the target items with the source item (if there are transformations to perform)
-                const mergedItems = {
-                    ...(sourceObjectOptions.transform
-                        ? defaultLocaleSourceItem
-                        : {}),
-                    ...targetItems,
-                };
-                // 4. Validate that the mergedItems is not empty
-                if (Object.keys(mergedItems).length === 0) {
-                    logger.warn(`Translated JSON for locale: ${target.targetLocale} does not have a valid sourceObjectPointer: ${sourceObjectPointer}. Skipping this target`);
-                    continue;
-                }
-                // 5. Override the source item with the translated values
-                for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries(mergedItems || {})) {
-                    try {
-                        const value = getJSONPointerValue(mutateSourceItem, translatedKeyJsonPointer);
-                        if (!value)
-                            continue;
-                        setJSONPointerValue(mutateSourceItem, translatedKeyJsonPointer, translatedValue);
-                    }
-                    catch {
-                        /* empty */
-                    }
-                }
-                // 6. Apply additional mutations to the sourceItem
-                applyTransformations(mutateSourceItem, sourceObjectOptions.transform, target.targetLocale, defaultLocale);
-                // 7. Merge the source item with the original JSON
-                sourceObjectRecord[mutateSourceItemKey] = mutateSourceItem;
-            }
-            setJSONPointerValue(mergedJson, sourceObjectPointer, sourceObjectValue);
-        }
-    }
-    if (jsonSchema.structuralTransform && jsonSchema.composite) {
-        unapplyStructuralTransforms(mergedJson, jsonSchema.structuralTransform, jsonSchema.composite);
-    }
-    return [JSON.stringify(mergedJson, null, 2)];
+import { logger } from "../../console/logger.js";
+import { gt } from "../../utils/gt.js";
+import { exitSync } from "../../console/logging.js";
+import { getJSONPathMatches, getJSONPathValues } from "./jsonPath.js";
+import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, getIdentifyingLocaleProperty, getSourceObjectOptionsArray, validateJsonSchema } from "./utils.js";
+import { getJSONPointerValue, setJSONPointerValue } from "./jsonPointer.js";
+import { applyStructuralTransforms, unapplyStructuralTransforms } from "./transformJson.js";
+import { replaceLocalePlaceholders } from "../utils.js";
+import { getLocaleProperties } from "@generaltranslation/format";
+//#region src/formats/json/mergeJson.ts
+function mergeJson(originalContent, inputPath, options, targets, defaultLocale, localeOrder = []) {
+	const jsonSchema = validateJsonSchema(options, inputPath);
+	if (!jsonSchema) return targets.map((target) => target.translatedContent);
+	let originalJson;
+	try {
+		originalJson = JSON.parse(originalContent);
+	} catch {
+		logger.error(`Invalid JSON file: ${inputPath}`);
+		return exitSync(1);
+	}
+	const useCanonicalLocaleKeys = options?.experimentalCanonicalLocaleKeys ?? false;
+	const canonicalDefaultLocale = useCanonicalLocaleKeys ? gt.resolveCanonicalLocale(defaultLocale) : defaultLocale;
+	const canonicalLocaleOrder = useCanonicalLocaleKeys ? localeOrder.map((locale) => gt.resolveCanonicalLocale(locale)) : localeOrder;
+	if (jsonSchema.structuralTransform && jsonSchema.composite) applyStructuralTransforms(originalJson, jsonSchema.structuralTransform, jsonSchema.composite);
+	if (jsonSchema.include) {
+		const output = [];
+		for (const target of targets) {
+			const mergedJson = structuredClone(originalJson);
+			const translatedJson = JSON.parse(target.translatedContent);
+			for (const [jsonPointer, translatedValue] of Object.entries(translatedJson)) try {
+				if (!getJSONPointerValue(mergedJson, jsonPointer)) continue;
+				setJSONPointerValue(mergedJson, jsonPointer, translatedValue);
+			} catch {}
+			output.push(JSON.stringify(mergedJson, null, 2));
+		}
+		return output;
+	}
+	if (!jsonSchema.composite) {
+		logger.error("No composite property found in JSON schema");
+		return exitSync(1);
+	}
+	const mergedJson = structuredClone(originalJson);
+	const parsedTargets = targets.map((target) => ({
+		...target,
+		parsedContent: JSON.parse(target.translatedContent)
+	}));
+	const sourceObjectPointers = generateSourceObjectPointers(jsonSchema.composite, originalJson);
+	for (const [sourceObjectPointer, { sourceObjectValue, sourceObjectOptions }] of Object.entries(sourceObjectPointers)) if (sourceObjectOptions.type === "array") {
+		if (!Array.isArray(sourceObjectValue)) {
+			logger.error(`Source object value is not an array at path: ${sourceObjectPointer}`);
+			return exitSync(1);
+		}
+		const matchingDefaultLocaleItems = findMatchingItemArray(canonicalDefaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
+		if (!Object.keys(matchingDefaultLocaleItems).length) {
+			logger.warn(`Matching sourceItems not found at path: ${sourceObjectPointer}. Check that your JSON file includes the key field. Skipping this target`);
+			continue;
+		}
+		const matchingDefaultLocaleItemKeys = new Set(Object.keys(matchingDefaultLocaleItems));
+		const indiciesToRemove = /* @__PURE__ */ new Set();
+		const itemsToAdd = [];
+		for (const target of parsedTargets) {
+			let targetItems = target.parsedContent[sourceObjectPointer];
+			if (!targetItems) targetItems = {};
+			const targetItemsToRemove = findMatchingItemArray(useCanonicalLocaleKeys ? gt.resolveCanonicalLocale(target.targetLocale) : target.targetLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
+			Object.values(targetItemsToRemove).forEach(({ index }) => indiciesToRemove.add(index));
+			const sourceKeys = [...matchingDefaultLocaleItemKeys];
+			const remappedTargetItems = {};
+			for (const [key, value] of Object.entries(targetItems)) if (matchingDefaultLocaleItemKeys.has(key)) remappedTargetItems[key] = value;
+			else if (sourceKeys.length === 1 && !(sourceKeys[0] in remappedTargetItems)) remappedTargetItems[sourceKeys[0]] = value;
+			else logger.warn(`Skipping translated item at ${key}: cannot map to source item at path ${sourceObjectPointer}`);
+			const mergedItems = {
+				...sourceObjectOptions.transform ? matchingDefaultLocaleItems : {},
+				...remappedTargetItems
+			};
+			if (Object.keys(mergedItems).length === 0) {
+				logger.warn(`Translated JSON for locale: ${target.targetLocale} does not have a valid sourceObjectPointer: ${sourceObjectPointer}. Skipping this target`);
+				continue;
+			}
+			for (const [sourceItemPointer, targetItem] of Object.entries(mergedItems)) {
+				if (!matchingDefaultLocaleItemKeys.has(sourceItemPointer)) {
+					logger.warn(`Skipping translated item at ${sourceItemPointer}: not present in source json at path ${sourceObjectPointer}`);
+					continue;
+				}
+				const defaultLocaleSourceItem = matchingDefaultLocaleItems[sourceItemPointer].sourceItem;
+				const defaultLocaleKeyPointer = matchingDefaultLocaleItems[sourceItemPointer].keyPointer;
+				const mutatedSourceItem = structuredClone(defaultLocaleSourceItem);
+				const { identifyingLocaleProperty: targetLocaleKeyProperty } = getSourceObjectOptionsArray(useCanonicalLocaleKeys ? gt.resolveCanonicalLocale(target.targetLocale) : target.targetLocale, sourceObjectPointer, sourceObjectOptions);
+				setJSONPointerValue(mutatedSourceItem, defaultLocaleKeyPointer, targetLocaleKeyProperty);
+				for (const [translatedKeyJsonPointer, translatedValue] of Object.entries(targetItem || {})) {
+					const valueToSet = useCanonicalLocaleKeys && defaultLocaleKeyPointer && translatedKeyJsonPointer === defaultLocaleKeyPointer ? targetLocaleKeyProperty : translatedValue;
+					try {
+						if (!getJSONPointerValue(mutatedSourceItem, translatedKeyJsonPointer)) continue;
+						setJSONPointerValue(mutatedSourceItem, translatedKeyJsonPointer, valueToSet);
+					} catch {}
+				}
+				applyTransformations(mutatedSourceItem, sourceObjectOptions.transform, target.targetLocale, defaultLocale);
+				itemsToAdd.push(mutatedSourceItem);
+			}
+		}
+		if (itemsToAdd.length < indiciesToRemove.size) logger.warn(`Items to add (${itemsToAdd.length}) is less than items to remove (${indiciesToRemove.size}) at path: ${sourceObjectPointer}. Some translated items may have been skipped.`);
+		const filteredSourceObjectValue = sourceObjectValue.filter((_, index) => !indiciesToRemove.has(index));
+		filteredSourceObjectValue.push(...itemsToAdd);
+		setJSONPointerValue(mergedJson, sourceObjectPointer, sortByLocaleOrder(filteredSourceObjectValue, sourceObjectOptions, canonicalLocaleOrder, sourceObjectPointer, canonicalDefaultLocale));
+	} else {
+		if (typeof sourceObjectValue !== "object" || sourceObjectValue === null) {
+			logger.error(`Source object value is not an object at path: ${sourceObjectPointer}`);
+			return exitSync(1);
+		}
+		const sourceObjectRecord = sourceObjectValue;
+		const matchingDefaultLocaleItem = findMatchingItemObject(canonicalDefaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectRecord);
+		if (!matchingDefaultLocaleItem.sourceItem) {
+			logger.error(`Source item not found at path: ${sourceObjectPointer}. You must specify a source item where its key matches the default locale`);
+			return exitSync(1);
+		}
+		const { sourceItem: defaultLocaleSourceItem } = matchingDefaultLocaleItem;
+		for (const target of parsedTargets) {
+			let targetItems = target.parsedContent[sourceObjectPointer];
+			if (targetItems == null) targetItems = {};
+			const mutateSourceItemKey = findMatchingItemObject(useCanonicalLocaleKeys ? gt.resolveCanonicalLocale(target.targetLocale) : target.targetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectRecord).keyParentProperty;
+			if (typeof defaultLocaleSourceItem === "string") {
+				if (typeof targetItems === "string") sourceObjectRecord[mutateSourceItemKey] = targetItems;
+				continue;
+			}
+			const mutateSourceItem = structuredClone(defaultLocaleSourceItem);
+			const mergedItems = {
+				...sourceObjectOptions.transform ? defaultLocaleSourceItem : {},
+				...targetItems
+			};
+			if (Object.keys(mergedItems).length === 0) {
+				logger.warn(`Translated JSON for locale: ${target.targetLocale} does not have a valid sourceObjectPointer: ${sourceObjectPointer}. Skipping this target`);
+				continue;
+			}
+			for (const [translatedKeyJsonPointer, translatedValue] of Object.entries(mergedItems || {})) try {
+				if (!getJSONPointerValue(mutateSourceItem, translatedKeyJsonPointer)) continue;
+				setJSONPointerValue(mutateSourceItem, translatedKeyJsonPointer, translatedValue);
+			} catch {}
+			applyTransformations(mutateSourceItem, sourceObjectOptions.transform, target.targetLocale, defaultLocale);
+			sourceObjectRecord[mutateSourceItemKey] = mutateSourceItem;
+		}
+		setJSONPointerValue(mergedJson, sourceObjectPointer, sourceObjectValue);
+	}
+	if (jsonSchema.structuralTransform && jsonSchema.composite) unapplyStructuralTransforms(mergedJson, jsonSchema.structuralTransform, jsonSchema.composite);
+	return [JSON.stringify(mergedJson, null, 2)];
 }
 function sortByLocaleOrder(items, sourceObjectOptions, localeOrder, sourceObjectPointer, defaultLocale) {
-    const sortMode = sourceObjectOptions.experimentalSort;
-    if (!sortMode || !sourceObjectOptions.key) {
-        return items;
-    }
-    const itemsWithLocale = items.map((item) => {
-        let localeValue;
-        try {
-            const values = getJSONPathValues(item, sourceObjectOptions.key);
-            const value = values?.[0];
-            if (typeof value === 'string') {
-                localeValue = value;
-            }
-        }
-        catch {
-            /* empty */
-        }
-        return { item, localeValue };
-    });
-    if (sortMode === 'locales') {
-        if (!localeOrder.length) {
-            return items;
-        }
-        const orderedLocaleList = [
-            defaultLocale,
-            ...localeOrder.filter((locale) => locale !== defaultLocale),
-        ];
-        const localeOrderValues = orderedLocaleList.map((locale) => getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions));
-        const orderedItems = [];
-        const remainingItems = [...itemsWithLocale];
-        for (const localeValue of localeOrderValues) {
-            for (let i = 0; i < remainingItems.length;) {
-                const entry = remainingItems[i];
-                if (entry.localeValue === localeValue) {
-                    orderedItems.push(entry.item);
-                    remainingItems.splice(i, 1);
-                    continue;
-                }
-                i += 1;
-            }
-        }
-        remainingItems.forEach((entry) => orderedItems.push(entry.item));
-        return orderedItems;
-    }
-    if (sortMode === 'localesAlphabetical') {
-        const defaultLocaleValue = getIdentifyingLocaleProperty(defaultLocale, sourceObjectPointer, sourceObjectOptions);
-        const defaultItems = [];
-        const sortableItems = [];
-        const remainingItems = [];
-        for (const entry of itemsWithLocale) {
-            if (entry.localeValue === defaultLocaleValue) {
-                defaultItems.push(entry);
-                continue;
-            }
-            if (entry.localeValue) {
-                sortableItems.push(entry);
-                continue;
-            }
-            remainingItems.push(entry);
-        }
-        sortableItems.sort((a, b) => {
-            if (!a.localeValue || !b.localeValue) {
-                return 0;
-            }
-            return a.localeValue.localeCompare(b.localeValue);
-        });
-        return [...defaultItems, ...sortableItems, ...remainingItems].map((entry) => entry.item);
-    }
-    return items;
+	const sortMode = sourceObjectOptions.experimentalSort;
+	if (!sortMode || !sourceObjectOptions.key) return items;
+	const itemsWithLocale = items.map((item) => {
+		let localeValue;
+		try {
+			const value = getJSONPathValues(item, sourceObjectOptions.key)?.[0];
+			if (typeof value === "string") localeValue = value;
+		} catch {}
+		return {
+			item,
+			localeValue
+		};
+	});
+	if (sortMode === "locales") {
+		if (!localeOrder.length) return items;
+		const localeOrderValues = [defaultLocale, ...localeOrder.filter((locale) => locale !== defaultLocale)].map((locale) => getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions));
+		const orderedItems = [];
+		const remainingItems = [...itemsWithLocale];
+		for (const localeValue of localeOrderValues) for (let i = 0; i < remainingItems.length;) {
+			const entry = remainingItems[i];
+			if (entry.localeValue === localeValue) {
+				orderedItems.push(entry.item);
+				remainingItems.splice(i, 1);
+				continue;
+			}
+			i += 1;
+		}
+		remainingItems.forEach((entry) => orderedItems.push(entry.item));
+		return orderedItems;
+	}
+	if (sortMode === "localesAlphabetical") {
+		const defaultLocaleValue = getIdentifyingLocaleProperty(defaultLocale, sourceObjectPointer, sourceObjectOptions);
+		const defaultItems = [];
+		const sortableItems = [];
+		const remainingItems = [];
+		for (const entry of itemsWithLocale) {
+			if (entry.localeValue === defaultLocaleValue) {
+				defaultItems.push(entry);
+				continue;
+			}
+			if (entry.localeValue) {
+				sortableItems.push(entry);
+				continue;
+			}
+			remainingItems.push(entry);
+		}
+		sortableItems.sort((a, b) => {
+			if (!a.localeValue || !b.localeValue) return 0;
+			return a.localeValue.localeCompare(b.localeValue);
+		});
+		return [
+			...defaultItems,
+			...sortableItems,
+			...remainingItems
+		].map((entry) => entry.item);
+	}
+	return items;
 }
 /**
- * Apply transformations to the sourceItem in-place
- * @param sourceItem - The source item to apply transformations to
- * @param transform - The transformations to apply
- * @param targetLocale - The target locale
- * @param defaultLocale - The default locale
- */
-export function applyTransformations(sourceItem, transform, targetLocale, defaultLocale) {
-    if (!transform)
-        return;
-    const targetLocaleProperties = getLocaleProperties(targetLocale);
-    const defaultLocaleProperties = getLocaleProperties(defaultLocale);
-    for (const [transformPath, transformOptions] of Object.entries(transform)) {
-        if (!transformOptions.replace ||
-            typeof transformOptions.replace !== 'string') {
-            continue;
-        }
-        const results = getJSONPathMatches(sourceItem, transformPath);
-        if (!results || results.length === 0) {
-            continue;
-        }
-        results.forEach((result) => {
-            if (typeof result.value !== 'string') {
-                return;
-            }
-            // Replace locale placeholders in the replace string
-            let replaceString = transformOptions.replace;
-            // Replace all locale property placeholders
-            replaceString = replaceLocalePlaceholders(replaceString, targetLocaleProperties);
-            if (transformOptions.match &&
-                typeof transformOptions.match === 'string') {
-                // Replace locale placeholders in the match string using defaultLocale properties
-                let matchString = transformOptions.match;
-                matchString = replaceLocalePlaceholders(matchString, defaultLocaleProperties);
-                result.value = result.value.replace(new RegExp(matchString, 'g'), replaceString);
-            }
-            else {
-                result.value = replaceString;
-            }
-            // Update the actual sourceItem using JSONPointer
-            setJSONPointerValue(sourceItem, result.pointer, result.value);
-        });
-    }
+* Apply transformations to the sourceItem in-place
+* @param sourceItem - The source item to apply transformations to
+* @param transform - The transformations to apply
+* @param targetLocale - The target locale
+* @param defaultLocale - The default locale
+*/
+function applyTransformations(sourceItem, transform, targetLocale, defaultLocale) {
+	if (!transform) return;
+	const targetLocaleProperties = getLocaleProperties(targetLocale);
+	const defaultLocaleProperties = getLocaleProperties(defaultLocale);
+	for (const [transformPath, transformOptions] of Object.entries(transform)) {
+		if (!transformOptions.replace || typeof transformOptions.replace !== "string") continue;
+		const results = getJSONPathMatches(sourceItem, transformPath);
+		if (!results || results.length === 0) continue;
+		results.forEach((result) => {
+			if (typeof result.value !== "string") return;
+			let replaceString = transformOptions.replace;
+			replaceString = replaceLocalePlaceholders(replaceString, targetLocaleProperties);
+			if (transformOptions.match && typeof transformOptions.match === "string") {
+				let matchString = transformOptions.match;
+				matchString = replaceLocalePlaceholders(matchString, defaultLocaleProperties);
+				result.value = result.value.replace(new RegExp(matchString, "g"), replaceString);
+			} else result.value = replaceString;
+			setJSONPointerValue(sourceItem, result.pointer, result.value);
+		});
+	}
 }
+//#endregion
+export { applyTransformations, mergeJson };
+
+//# sourceMappingURL=mergeJson.js.map