gtx-cli 2.0.11 → 2.0.13

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.0.13
+
+### Patch Changes
+
+- [#505](https://github.com/generaltranslation/gt/pull/505) [`e8c5650`](https://github.com/generaltranslation/gt/commit/e8c5650c163119301d2f9d6b946c0ed8383c57e1) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - fix: json translation for composite arrays where there are multiple default locale items
+
+## 2.0.12
+
+### Patch Changes
+
+- [#503](https://github.com/generaltranslation/gt/pull/503) [`9549d88`](https://github.com/generaltranslation/gt/commit/9549d88485af4dc57fb19847016d53aa3375b380) Thanks [@brian-lou](https://github.com/brian-lou)! - Fix path resolution mechanism for useGT/getGT usage scanning
+
 ## 2.0.11
 
 ### Patch Changes

package/dist/config/optionPresets.js

@@ -21,22 +21,21 @@ export function generatePreset(preset) {
                             },
                         },
                     },
-                    // Enable this when support multiple language objects in array
-                    // '$.redirects': {
-                    //   type: 'array',
-                    //   key: '$.language',
-                    //   include: [],
-                    //   transform: {
-                    //     '$.source': {
-                    //       match: '^/{locale}/(.*)$',
-                    //       replace: '/{locale}/$1',
-                    //     },
-                    //     '$.destination': {
-                    //       match: '^/{locale}/(.*)$',
-                    //       replace: '/{locale}/$1',
-                    //     },
-                    //   },
-                    // },
+                    '$.redirects': {
+                        type: 'array',
+                        key: '$.language',
+                        include: [],
+                        transform: {
+                            '$.source': {
+                                match: '^/{locale}/(.*)$',
+                                replace: '/{locale}/$1',
+                            },
+                            '$.destination': {
+                                match: '^/{locale}/(.*)$',
+                                replace: '/{locale}/$1',
+                            },
+                        },
+                    },
                 },
             };
         default:

package/dist/formats/json/flattenJson.js

@@ -56,7 +56,7 @@ export function flattenJsonWithStringFilter(json, jsonPaths) {
                 }
             });
         }
-        catch (error) {
+        catch {
             logError(`Error with JSONPath pattern: ${jsonPath}`);
         }
     }

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

@@ -3,4 +3,11 @@ export declare function mergeJson(originalContent: string, filePath: string, opt
     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

@@ -12,7 +12,7 @@ export function mergeJson(originalContent, filePath, options, targets, defaultLo
     try {
         originalJson = JSON.parse(originalContent);
     }
-    catch (error) {
+    catch {
         logError(`Invalid JSON file: ${filePath}`);
         exit(1);
     }
@@ -55,57 +55,85 @@ export function mergeJson(originalContent, filePath, options, targets, defaultLo
                 exit(1);
             }
             // Get source item for default locale
-            const matchingDefaultLocaleItem = findMatchingItemArray(defaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-            if (!matchingDefaultLocaleItem) {
-                logError(`Matching sourceItem not found at path: ${sourceObjectPointer} for locale: ${defaultLocale}. Please check your JSON schema`);
+            const matchingDefaultLocaleItems = findMatchingItemArray(defaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
+            if (!Object.keys(matchingDefaultLocaleItems).length) {
+                logError(`Matching sourceItems not found at path: ${sourceObjectPointer} for locale: ${defaultLocale}. Please check your JSON schema`);
                 exit(1);
             }
-            const { sourceItem: defaultLocaleSourceItem, keyPointer: defaultLocaleKeyPointer, } = matchingDefaultLocaleItem;
+            const matchingDefaultLocaleItemKeys = new Set(Object.keys(matchingDefaultLocaleItems));
             // For each target:
-            // 1. Validate that the targetJson has a jsonPointer for the current sourceObjectPointer
-            // 2. If it does, find the source item for the target locale
-            // 3. Override the source item with the translated values
-            // 4. Apply additional mutations to the sourceItem
-            // 5. Merge the source item with the original JSON
+            // 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);
-                // 1. Validate that the targetJson has a jsonPointer for the current sourceObjectPointer
-                if (!targetJson[sourceObjectPointer]) {
+                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;
                 }
-                // 2. Find the source item for the target locale
-                const matchingTargetItem = findMatchingItemArray(target.targetLocale, sourceObjectOptions, sourceObjectPointer, 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 mutateSourceItemIndex = matchingTargetItem
-                    ? matchingTargetItem.itemIndex
-                    : undefined;
-                const mutateSourceItemKeyPointer = defaultLocaleKeyPointer;
-                const { identifyingLocaleProperty: targetLocaleKeyProperty } = getSourceObjectOptionsArray(target.targetLocale, sourceObjectPointer, sourceObjectOptions);
-                // 3. Override the source item with the translated values
-                JSONPointer.set(mutateSourceItem, mutateSourceItemKeyPointer, targetLocaleKeyProperty);
-                for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries(targetJson[sourceObjectPointer] || {})) {
-                    try {
-                        const value = JSONPointer.get(mutateSourceItem, translatedKeyJsonPointer);
-                        if (!value)
-                            continue;
-                        JSONPointer.set(mutateSourceItem, translatedKeyJsonPointer, translatedValue);
+                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);
                     }
-                    catch (error) { }
-                }
-                // 4. Apply additional mutations to the sourceItem
-                applyTransformations(mutateSourceItem, sourceObjectOptions.transform, target.targetLocale, defaultLocale);
-                // 5. Merge the source item with the original JSON
-                if (mutateSourceItemIndex) {
-                    sourceObjectValue[mutateSourceItemIndex] = mutateSourceItem;
-                }
-                else {
-                    sourceObjectValue.push(mutateSourceItem);
+                    // 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);
                 }
             }
-            JSONPointer.set(mergedJson, sourceObjectPointer, sourceObjectValue);
+            // 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
@@ -122,17 +150,19 @@ export function mergeJson(originalContent, filePath, options, targets, defaultLo
             }
             const { sourceItem: defaultLocaleSourceItem } = matchingDefaultLocaleItem;
             // For each target:
-            // 1. Validate that the targetJson has a jsonPointer for the current sourceObjectPointer
-            // 2. If it does, find the source item for the target locale
-            // 3. Override the source item with the translated values
-            // 4. Apply additional mutations to the sourceItem
-            // 5. Merge the source item with the original JSON
+            // 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. Validate that the targetJson has a jsonPointer for the current sourceObjectPointer
-                if (!targetJson[sourceObjectPointer]) {
-                    logWarning(`Translated JSON for locale: ${target.targetLocale} does not have a valid sourceObjectPointer: ${sourceObjectPointer}. Skipping this target`);
-                    continue;
+                // 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);
@@ -140,19 +170,31 @@ export function mergeJson(originalContent, filePath, options, targets, defaultLo
                 // Otherwise, fallback to the default locale source item
                 const mutateSourceItem = structuredClone(defaultLocaleSourceItem);
                 const mutateSourceItemKey = matchingTargetItem.keyParentProperty;
-                // 3. Override the source item with the translated values
-                for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries(targetJson[sourceObjectPointer] || {})) {
+                // 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 (error) { }
+                    catch {
+                        /* empty */
+                    }
                 }
-                // 4. Apply additional mutations to the sourceItem
+                // 6. Apply additional mutations to the sourceItem
                 applyTransformations(mutateSourceItem, sourceObjectOptions.transform, target.targetLocale, defaultLocale);
-                // 5. Merge the source item with the original JSON
+                // 7. Merge the source item with the original JSON
                 sourceObjectValue[mutateSourceItemKey] = mutateSourceItem;
             }
             JSONPointer.set(mergedJson, sourceObjectPointer, sourceObjectValue);
@@ -184,7 +226,13 @@ function replaceLocalePlaceholders(string, localeProperties) {
         return match;
     });
 }
-// apply transformations to the sourceItem in-place
+/**
+ * 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;

package/dist/formats/json/parseJson.js

@@ -12,7 +12,7 @@ export function parseJson(content, filePath, options, defaultLocale) {
     try {
         json = JSON.parse(content);
     }
-    catch (error) {
+    catch {
         logError(`Invalid JSON file: ${filePath}`);
         exit(1);
     }
@@ -31,6 +31,10 @@ export function parseJson(content, filePath, options, defaultLocale) {
     // 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') {
@@ -39,38 +43,45 @@ export function parseJson(content, filePath, options, defaultLocale) {
                 logError(`Source object value is not an array at path: ${sourceObjectPointer}`);
                 exit(1);
             }
-            // Validate localeProperty
-            const matchingItem = findMatchingItemArray(defaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-            if (!matchingItem) {
+            // 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);
             }
-            const { sourceItem, keyPointer } = matchingItem;
-            // Get the fields to translate from the includes
-            let itemsToTranslate = [];
-            for (const include of sourceObjectOptions.include) {
-                try {
-                    const matchingItems = JSONPath({
-                        json: sourceItem,
-                        path: include,
-                        resultType: 'all',
-                        flatten: true,
-                        wrap: true,
-                    });
-                    if (matchingItems) {
-                        itemsToTranslate.push(...matchingItems);
+            // 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 */
                     }
                 }
-                catch (error) { }
+                // Filter out the key pointer
+                sourceItemsToTranslate[arrayPointer] = Object.fromEntries(matchingItemsToTranslate
+                    .filter((item) => item.pointer !== keyPointer)
+                    .map((item) => [
+                    item.pointer,
+                    item.value,
+                ]));
             }
-            itemsToTranslate = Object.fromEntries(itemsToTranslate
-                .filter((item) => item.pointer !== keyPointer)
-                .map((item) => [
-                item.pointer,
-                item.value,
-            ]));
             // Add the items to translate to the result
-            sourceObjectsToTranslate[sourceObjectPointer] = itemsToTranslate;
+            sourceObjectsToTranslate[sourceObjectPointer] = sourceItemsToTranslate;
         }
         else {
             // Object: use the key in this object with the matching locale property

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

@@ -1,15 +1,29 @@
 import { AdditionalOptions, JsonSchema, SourceObjectOptions } from '../../types/index.js';
-export declare function findMatchingItemArray(locale: string, sourceObjectOptions: SourceObjectOptions, sourceObjectPointer: string, sourceObjectValue: any): {
+export declare function findMatchingItemArray(locale: string, sourceObjectOptions: SourceObjectOptions, sourceObjectPointer: string, sourceObjectValue: any): Record<string, {
     sourceItem: any;
     keyParentProperty: string;
-    itemIndex: number;
     keyPointer: string;
-} | null;
+    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;
@@ -17,6 +31,13 @@ export declare function getSourceObjectOptionsArray(locale: string, sourceObject
 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, {

package/dist/formats/json/utils.js

@@ -11,6 +11,7 @@ const { isMatch } = micromatch;
 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({
@@ -24,23 +25,28 @@ export function findMatchingItemArray(locale, sourceObjectOptions, sourceObjectP
             logError(`Source item at path: ${sourceObjectPointer} does not have a key value at path: ${localeKeyJsonPath}`);
             exit(1);
         }
-        else if (keyCandidates.length !== 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);
         }
-        // Validate the key is the identifying locale property
-        if (!keyCandidates.length ||
-            identifyingLocaleProperty !== keyCandidates[0].value) {
+        else if (identifyingLocaleProperty !== keyCandidates[0].value) {
+            // Validate the key is the identifying locale property
             continue;
         }
-        return {
+        // Map the index to the source item
+        matchingItems[`/${index}`] = {
             sourceItem: item,
             keyParentProperty: keyCandidates[0].parentProperty,
-            itemIndex: index,
             keyPointer: keyCandidates[0].pointer,
+            index,
         };
     }
-    return null;
+    return matchingItems;
 }
 export function findMatchingItemObject(locale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue) {
     const { identifyingLocaleProperty } = getSourceObjectOptionsObject(locale, sourceObjectPointer, sourceObjectOptions);
@@ -56,6 +62,13 @@ export function findMatchingItemObject(locale, sourceObjectPointer, sourceObject
         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';
@@ -66,6 +79,13 @@ export function getIdentifyingLocaleProperty(locale, sourceObjectPointer, source
     }
     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;
@@ -84,8 +104,13 @@ export function getSourceObjectOptionsObject(defaultLocale, sourceObjectPointer,
     }
     return { identifyingLocaleProperty };
 }
-// Generate a mapping of sourceObjectPointer to SourceObjectOptions
-// where the sourceObjectPointer is a jsonpointer to the array or object containing
+/**
+ * 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]);

package/dist/react/jsx/utils/parseStringFunction.js

@@ -11,7 +11,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parse } from '@babel/parser';
 import { createMatchPath, loadConfig } from 'tsconfig-paths';
-import * as resolve from 'resolve';
+import resolve from 'resolve';
 /**
  * Processes a single translation function call (e.g., t('hello world', { id: 'greeting' })).
  * Extracts the translatable string content and metadata, then adds it to the updates array.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [