gt 0.10.0 → 2.7.0

package/dist/formats/json/flattenJson.js

@@ -0,0 +1,64 @@
+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;
+}

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

@@ -0,0 +1,13 @@
+import { AdditionalOptions, SourceObjectOptions } from '../../types/index.js';
+export declare function mergeJson(originalContent: string, inputPath: string, options: AdditionalOptions, targets: {
+    translatedContent: string;
+    targetLocale: string;
+}[], defaultLocale: string, localeOrder?: string[]): string[];
+/**
+ * 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 declare function applyTransformations(sourceItem: any, transform: SourceObjectOptions['transform'], targetLocale: string, defaultLocale: string): void;

package/dist/formats/json/mergeJson.js

@@ -0,0 +1,367 @@
+import JSONPointer from 'jsonpointer';
+import { exitSync } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
+import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, getIdentifyingLocaleProperty, getSourceObjectOptionsArray, validateJsonSchema, } from './utils.js';
+import { JSONPath } from 'jsonpath-plus';
+import { getLocaleProperties } from 'generaltranslation';
+import { replaceLocalePlaceholders } from '../utils.js';
+import { gt } from '../../utils/gt.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;
+    // 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 = JSONPointer.get(mergedJson, jsonPointer);
+                    if (!value)
+                        continue;
+                    JSONPointer.set(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);
+    // 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}. Please check 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 targets) {
+                const targetJson = JSON.parse(target.translatedContent);
+                let targetItems = targetJson[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);
+                    JSONPointer.set(mutatedSourceItem, defaultLocaleKeyPointer, targetLocaleKeyProperty);
+                    for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries(targetItem || {})) {
+                        const valueToSet = useCanonicalLocaleKeys &&
+                            defaultLocaleKeyPointer &&
+                            translatedKeyJsonPointer === defaultLocaleKeyPointer
+                            ? targetLocaleKeyProperty
+                            : translatedValue;
+                        try {
+                            const value = JSONPointer.get(mutatedSourceItem, translatedKeyJsonPointer);
+                            if (!value)
+                                continue;
+                            JSONPointer.set(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);
+            JSONPointer.set(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);
+            }
+            // Validate localeProperty
+            const matchingDefaultLocaleItem = findMatchingItemObject(canonicalDefaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+            // 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 targets) {
+                const targetJson = JSON.parse(target.translatedContent);
+                // 1. Get the target items
+                let targetItems = targetJson[sourceObjectPointer];
+                if (!targetItems) {
+                    targetItems = {};
+                }
+                // 2. Find the source item for the target locale
+                const matchingTargetItem = findMatchingItemObject(useCanonicalLocaleKeys
+                    ? gt.resolveCanonicalLocale(target.targetLocale)
+                    : target.targetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+                // 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);
+                const mutateSourceItemKey = matchingTargetItem.keyParentProperty;
+                // 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 = JSONPointer.get(mutateSourceItem, translatedKeyJsonPointer);
+                        if (!value)
+                            continue;
+                        JSONPointer.set(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
+                sourceObjectValue[mutateSourceItemKey] = mutateSourceItem;
+            }
+            JSONPointer.set(mergedJson, sourceObjectPointer, sourceObjectValue);
+        }
+    }
+    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 = JSONPath({
+                json: item,
+                path: sourceObjectOptions.key,
+                resultType: 'value',
+                flatten: true,
+                wrap: true,
+            });
+            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;
+}
+/**
+ * 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 = JSONPath({
+            json: sourceItem,
+            path: transformPath,
+            resultType: 'all',
+            flatten: true,
+            wrap: true,
+        });
+        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
+            JSONPointer.set(sourceItem, result.pointer, result.value);
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+import { AdditionalOptions } from '../../types/index.js';
+export declare function parseJson(content: string, filePath: string, options: AdditionalOptions, defaultLocale: string): string;

package/dist/formats/json/parseJson.js

@@ -0,0 +1,109 @@
+import { flattenJsonWithStringFilter } from './flattenJson.js';
+import { JSONPath } from 'jsonpath-plus';
+import { exitSync } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
+import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, validateJsonSchema, } from './utils.js';
+// Parse a JSON file according to a JSON schema
+export function parseJson(content, filePath, options, defaultLocale) {
+    const jsonSchema = validateJsonSchema(options, filePath);
+    if (!jsonSchema) {
+        return content;
+    }
+    let json;
+    try {
+        json = JSON.parse(content);
+    }
+    catch {
+        logger.error(`Invalid JSON file: ${filePath}`);
+        return exitSync(1);
+    }
+    // Handle include
+    if (jsonSchema.include) {
+        const flattenedJson = flattenJsonWithStringFilter(json, jsonSchema.include);
+        return JSON.stringify(flattenedJson);
+    }
+    if (!jsonSchema.composite) {
+        logger.error('No composite property found in JSON schema');
+        return exitSync(1);
+    }
+    // Construct lvl 1
+    // Create mapping of sourceObjectPointer to SourceObjectOptions
+    const sourceObjectPointers = generateSourceObjectPointers(jsonSchema.composite, json);
+    // Construct lvl 2
+    const sourceObjectsToTranslate = {};
+    for (const [sourceObjectPointer, { sourceObjectValue, sourceObjectOptions },] of Object.entries(sourceObjectPointers)) {
+        // Skip if no includes
+        if (!sourceObjectOptions.include.length) {
+            continue;
+        }
+        // Find the default locale in each source item in each sourceObjectValue
+        // Array: use key field
+        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);
+            }
+            // Find matching source items
+            const matchingItems = findMatchingItemArray(defaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
+            if (!Object.keys(matchingItems).length) {
+                logger.error(`Matching sourceItem not found at path: ${sourceObjectPointer} for locale: ${defaultLocale}. Please check your JSON schema`);
+                return exitSync(1);
+            }
+            // Construct lvl 3
+            const sourceItemsToTranslate = {};
+            for (const [arrayPointer, matchingItem] of Object.entries(matchingItems)) {
+                const { sourceItem, keyPointer } = matchingItem;
+                // Get the fields to translate from the includes
+                const matchingItemsToTranslate = [];
+                for (const include of sourceObjectOptions.include) {
+                    try {
+                        const matchingItems = JSONPath({
+                            json: sourceItem,
+                            path: include,
+                            resultType: 'all',
+                            flatten: true,
+                            wrap: true,
+                        });
+                        if (matchingItems) {
+                            matchingItemsToTranslate.push(...matchingItems);
+                        }
+                    }
+                    catch {
+                        /* empty */
+                    }
+                }
+                // Filter out the key pointer
+                sourceItemsToTranslate[arrayPointer] = Object.fromEntries(matchingItemsToTranslate
+                    .filter((item) => item.pointer !== keyPointer)
+                    .map((item) => [
+                    item.pointer,
+                    item.value,
+                ]));
+            }
+            // Add the items to translate to the result
+            sourceObjectsToTranslate[sourceObjectPointer] = sourceItemsToTranslate;
+        }
+        else {
+            // Object: use the key in this object with the matching locale property
+            // Validate type
+            if (typeof sourceObjectValue !== 'object' || sourceObjectValue === null) {
+                logger.error(`Source object value is not an object at path: ${sourceObjectPointer}`);
+                return exitSync(1);
+            }
+            // Validate localeProperty
+            const matchingItem = findMatchingItemObject(defaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+            // Validate source item exists
+            if (!matchingItem.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 } = matchingItem;
+            // Get the fields to translate from the includes
+            const itemsToTranslate = flattenJsonWithStringFilter(sourceItem, sourceObjectOptions.include);
+            // Add the items to translate to the result
+            sourceObjectsToTranslate[sourceObjectPointer] = itemsToTranslate;
+        }
+    }
+    return JSON.stringify(sourceObjectsToTranslate);
+}

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

@@ -0,0 +1,47 @@
+import { AdditionalOptions, JsonSchema, SourceObjectOptions } from '../../types/index.js';
+export declare function findMatchingItemArray(locale: string, sourceObjectOptions: SourceObjectOptions, sourceObjectPointer: string, sourceObjectValue: any): Record<string, {
+    sourceItem: any;
+    keyParentProperty: string;
+    keyPointer: string;
+    index: number;
+}>;
+export declare function findMatchingItemObject(locale: string, sourceObjectPointer: string, sourceObjectOptions: SourceObjectOptions, sourceObjectValue: any): {
+    sourceItem: any | undefined;
+    keyParentProperty: string;
+};
+/**
+ * Get the identifying locale property for an object
+ * @param locale - The locale to get the identifying locale property for
+ * @param sourceObjectPointer - The path to the source object
+ * @param sourceObjectOptions - The source object options
+ * @returns The identifying locale property
+ */
+export declare function getIdentifyingLocaleProperty(locale: string, sourceObjectPointer: string, sourceObjectOptions: SourceObjectOptions): string;
+/**
+ * Get the identifying locale property and the json path to the key for an array
+ * @param locale - The locale to get the identifying locale property for
+ * @param sourceObjectPointer - The path to the source object
+ * @param sourceObjectOptions - The source object options
+ * @returns The identifying locale property and the json path to the key
+ */
+export declare function getSourceObjectOptionsArray(locale: string, sourceObjectPointer: string, sourceObjectOptions: SourceObjectOptions): {
+    identifyingLocaleProperty: string;
+    localeKeyJsonPath: string;
+};
+export declare function getSourceObjectOptionsObject(defaultLocale: string, sourceObjectPointer: string, sourceObjectOptions: SourceObjectOptions): {
+    identifyingLocaleProperty: string;
+};
+/**
+ * Generate a mapping of sourceObjectPointer to SourceObjectOptions
+ * where the sourceObjectPointer is a jsonpointer to the array or object containing
+ * @param jsonSchema - The json schema to generate the mapping from
+ * @param originalJson - The original json to generate the mapping from
+ * @returns A mapping of sourceObjectPointer to SourceObjectOptions
+ */
+export declare function generateSourceObjectPointers(jsonSchema: {
+    [sourceObjectPath: string]: SourceObjectOptions;
+}, originalJson: any): Record<string, {
+    sourceObjectValue: any;
+    sourceObjectOptions: SourceObjectOptions;
+}>;
+export declare function validateJsonSchema(options: AdditionalOptions, filePath: string): JsonSchema | null;