gtx-cli 2.3.5 → 2.3.6-alpha.2

package/dist/formats/json/flattenJson.js

@@ -1,64 +0,0 @@
-import { JSONPath } from 'jsonpath-plus';
-import { logError } from '../../console/logging.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) {
-            logError(`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 {
-            logError(`Error with JSONPath pattern: ${jsonPath}`);
-        }
-    }
-    return extractedJson;
-}

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

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

@@ -1,257 +0,0 @@
-import JSONPointer from 'jsonpointer';
-import { exit, logError, logWarning } from '../../console/logging.js';
-import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, getSourceObjectOptionsArray, validateJsonSchema, } from './utils.js';
-import { JSONPath } from 'jsonpath-plus';
-import { getLocaleProperties } from 'generaltranslation';
-import { replaceLocalePlaceholders } from '../utils.js';
-export function mergeJson(originalContent, inputPath, options, targets, defaultLocale) {
-    const jsonSchema = validateJsonSchema(options, inputPath);
-    if (!jsonSchema) {
-        return targets.map((target) => target.translatedContent);
-    }
-    let originalJson;
-    try {
-        originalJson = JSON.parse(originalContent);
-    }
-    catch {
-        logError(`Invalid JSON file: ${inputPath}`);
-        exit(1);
-    }
-    // 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) {
-        logError('No composite property found in JSON schema');
-        exit(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)) {
-                logError(`Source object value is not an array at path: ${sourceObjectPointer}`);
-                exit(1);
-            }
-            // Get source item for default locale
-            const matchingDefaultLocaleItems = findMatchingItemArray(defaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-            if (!Object.keys(matchingDefaultLocaleItems).length) {
-                logWarning(`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(target.targetLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-                Object.values(targetItemsToRemove).forEach(({ index }) => indiciesToRemove.add(index));
-                // 3. Merge matchingDefaultLocaleItems and targetItems
-                const mergedItems = {
-                    ...(sourceObjectOptions.transform ? matchingDefaultLocaleItems : {}),
-                    ...targetItems,
-                };
-                // 4. Validate that the mergedItems is not empty
-                if (Object.keys(mergedItems).length === 0) {
-                    logWarning(`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)) {
-                        logError(`Array index ${sourceItemPointer} is not present in the source json. It is possible that the source json has been modified since the translation was generated.`);
-                        exit(1);
-                    }
-                    // 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(target.targetLocale, sourceObjectPointer, sourceObjectOptions);
-                    JSONPointer.set(mutatedSourceItem, defaultLocaleKeyPointer, targetLocaleKeyProperty);
-                    for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries(targetItem || {})) {
-                        try {
-                            const value = JSONPointer.get(mutatedSourceItem, translatedKeyJsonPointer);
-                            if (!value)
-                                continue;
-                            JSONPointer.set(mutatedSourceItem, translatedKeyJsonPointer, translatedValue);
-                        }
-                        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 this happens, something is very wrong)
-            if (itemsToAdd.length < indiciesToRemove.size) {
-                logError(`Items to add is less than items to remove at path: ${sourceObjectPointer}. Please check your JSON schema key field.`);
-                exit(1);
-            }
-            // 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, filteredSourceObjectValue);
-        }
-        else {
-            // Validate type
-            if (typeof sourceObjectValue !== 'object' || sourceObjectValue === null) {
-                logError(`Source object value is not an object at path: ${sourceObjectPointer}`);
-                exit(1);
-            }
-            // Validate localeProperty
-            const matchingDefaultLocaleItem = findMatchingItemObject(defaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
-            // Validate source item exists
-            if (!matchingDefaultLocaleItem.sourceItem) {
-                logError(`Source item not found at path: ${sourceObjectPointer}. You must specify a source item where its key matches the default locale`);
-                exit(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(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) {
-                    logWarning(`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)];
-}
-/**
- * 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

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

@@ -1,108 +0,0 @@
-import { flattenJsonWithStringFilter } from './flattenJson.js';
-import { JSONPath } from 'jsonpath-plus';
-import { exit, logError } from '../../console/logging.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 {
-        logError(`Invalid JSON file: ${filePath}`);
-        exit(1);
-    }
-    // Handle include
-    if (jsonSchema.include) {
-        const flattenedJson = flattenJsonWithStringFilter(json, jsonSchema.include);
-        return JSON.stringify(flattenedJson);
-    }
-    if (!jsonSchema.composite) {
-        logError('No composite property found in JSON schema');
-        exit(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)) {
-                logError(`Source object value is not an array at path: ${sourceObjectPointer}`);
-                exit(1);
-            }
-            // Find matching source items
-            const matchingItems = findMatchingItemArray(defaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-            if (!Object.keys(matchingItems).length) {
-                logError(`Matching sourceItem not found at path: ${sourceObjectPointer} for locale: ${defaultLocale}. Please check your JSON schema`);
-                exit(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) {
-                logError(`Source object value is not an object at path: ${sourceObjectPointer}`);
-                exit(1);
-            }
-            // Validate localeProperty
-            const matchingItem = findMatchingItemObject(defaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
-            // Validate source item exists
-            if (!matchingItem.sourceItem) {
-                logError(`Source item not found at path: ${sourceObjectPointer}. You must specify a source item where its key matches the default locale`);
-                exit(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

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

package/dist/formats/json/utils.js

@@ -1,149 +0,0 @@
-import { getLocaleProperties } from 'generaltranslation';
-import { exit, logError } from '../../console/logging.js';
-import { JSONPath } from 'jsonpath-plus';
-import { flattenJson } from './flattenJson.js';
-import path from 'node:path';
-import micromatch from 'micromatch';
-const { isMatch } = micromatch;
-// Find the matching source item in an array
-// where the key matches the identifying locale property
-// If no matching item is found, exit with an error
-export function findMatchingItemArray(locale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue) {
-    const { identifyingLocaleProperty, localeKeyJsonPath } = getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions);
-    // Use the json pointer key to locate the source item
-    const matchingItems = {};
-    for (const [index, item] of sourceObjectValue.entries()) {
-        // Get the key candidates
-        const keyCandidates = JSONPath({
-            json: item,
-            path: localeKeyJsonPath,
-            resultType: 'all',
-            flatten: true,
-            wrap: true,
-        });
-        if (!keyCandidates) {
-            logError(`Source item at path: ${sourceObjectPointer} does not have a key value at path: ${localeKeyJsonPath}`);
-            exit(1);
-        }
-        else if (keyCandidates.length === 0) {
-            // If no key candidates, skip the item
-            continue;
-        }
-        else if (keyCandidates.length > 1) {
-            // If multiple key candidates, exit with an error
-            logError(`Source item at path: ${sourceObjectPointer} has multiple matching keys with path: ${localeKeyJsonPath}`);
-            exit(1);
-        }
-        else if (identifyingLocaleProperty !== keyCandidates[0].value) {
-            // Validate the key is the identifying locale property
-            continue;
-        }
-        // Map the index to the source item
-        matchingItems[`/${index}`] = {
-            sourceItem: item,
-            keyParentProperty: keyCandidates[0].parentProperty,
-            keyPointer: keyCandidates[0].pointer,
-            index,
-        };
-    }
-    return matchingItems;
-}
-export function findMatchingItemObject(locale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue) {
-    const { identifyingLocaleProperty } = getSourceObjectOptionsObject(locale, sourceObjectPointer, sourceObjectOptions);
-    // Locate the source item
-    if (sourceObjectValue[identifyingLocaleProperty]) {
-        return {
-            sourceItem: sourceObjectValue[identifyingLocaleProperty],
-            keyParentProperty: identifyingLocaleProperty,
-        };
-    }
-    return {
-        sourceItem: undefined,
-        keyParentProperty: identifyingLocaleProperty,
-    };
-}
-/**
- * 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 function getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions) {
-    // Validate localeProperty
-    const localeProperty = sourceObjectOptions.localeProperty || 'code';
-    const identifyingLocaleProperty = getLocaleProperties(locale)[localeProperty];
-    if (!identifyingLocaleProperty) {
-        logError(`Source object options localeProperty is not a valid locale property at path: ${sourceObjectPointer}`);
-        exit(1);
-    }
-    return identifyingLocaleProperty;
-}
-/**
- * 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 function getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions) {
-    const identifyingLocaleProperty = getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions);
-    const localeKeyJsonPath = sourceObjectOptions.key;
-    if (!localeKeyJsonPath) {
-        logError(`Source object options key is required for array at path: ${sourceObjectPointer}`);
-        exit(1);
-    }
-    return { identifyingLocaleProperty, localeKeyJsonPath };
-}
-export function getSourceObjectOptionsObject(defaultLocale, sourceObjectPointer, sourceObjectOptions) {
-    const identifyingLocaleProperty = getIdentifyingLocaleProperty(defaultLocale, sourceObjectPointer, sourceObjectOptions);
-    const jsonPathKey = sourceObjectOptions.key;
-    if (jsonPathKey) {
-        logError(`Source object options key is not allowed for object at path: ${sourceObjectPointer}`);
-        exit(1);
-    }
-    return { identifyingLocaleProperty };
-}
-/**
- * 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 function generateSourceObjectPointers(jsonSchema, originalJson) {
-    const sourceObjectPointers = Object.entries(jsonSchema).reduce((acc, [sourceObjectPath, sourceObjectOptions]) => {
-        const sourceObjects = flattenJson(originalJson, [sourceObjectPath]);
-        Object.entries(sourceObjects).forEach(([pointer, value]) => {
-            acc[pointer] = {
-                sourceObjectValue: value,
-                sourceObjectOptions,
-            };
-        });
-        return acc;
-    }, {});
-    return sourceObjectPointers;
-}
-export function validateJsonSchema(options, filePath) {
-    if (!options.jsonSchema) {
-        return null;
-    }
-    const fileGlobs = Object.keys(options.jsonSchema);
-    const matchingGlob = fileGlobs.find((fileGlob) => isMatch(path.relative(process.cwd(), filePath), fileGlob));
-    if (!matchingGlob || !options.jsonSchema[matchingGlob]) {
-        return null;
-    }
-    // Validate includes or composite
-    const jsonSchema = options.jsonSchema[matchingGlob];
-    if (jsonSchema.include && jsonSchema.composite) {
-        logError('include and composite cannot be used together in the same JSON schema');
-        exit(1);
-        return null;
-    }
-    if (!jsonSchema.include && !jsonSchema.composite) {
-        logError('No include or composite property found in JSON schema');
-        exit(1);
-        return null;
-    }
-    return jsonSchema;
-}

package/dist/formats/utils.d.ts

@@ -1,2 +0,0 @@
-import { LocaleProperties } from 'generaltranslation/types';
-export declare function replaceLocalePlaceholders(string: string, localeProperties: LocaleProperties): string;

package/dist/formats/utils.js

@@ -1,24 +0,0 @@
-// helper function to replace locale placeholders in a string
-// with the corresponding locale properties
-// ex: {locale} -> will be replaced with the locale code
-// ex: {localeName} -> will be replaced with the locale name
-export function replaceLocalePlaceholders(string, localeProperties) {
-    return string.replace(/\{(\w+)\}/g, (match, property) => {
-        // Handle common aliases
-        if (property === 'locale' || property === 'localeCode') {
-            return localeProperties.code;
-        }
-        if (property === 'localeName') {
-            return localeProperties.name;
-        }
-        if (property === 'localeNativeName') {
-            return localeProperties.nativeName;
-        }
-        // Check if the property exists in localeProperties
-        if (property in localeProperties) {
-            return localeProperties[property];
-        }
-        // Return the original placeholder if property not found
-        return match;
-    });
-}