gtx-cli 1.2.22 → 1.2.24-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 1.2.23
+
+### Patch Changes
+
+- [#336](https://github.com/generaltranslation/gt/pull/336) [`d22c287`](https://github.com/generaltranslation/gt/commit/d22c2871f1b474bc6cf981621a37400a92b4bbff) Thanks [@brian-lou](https://github.com/brian-lou)! - Fix string translation fallback function tracing when translating
+
 ## 1.2.22
 
 ### Patch Changes

package/dist/api/checkFileTranslations.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkFileTranslations = checkFileTranslations;
 const chalk_1 = __importDefault(require("chalk"));
 const console_1 = require("../console");
-const generaltranslation_1 = require("generaltranslation");
+const generaltranslation_1 = __importDefault(require("generaltranslation"));
 const downloadFile_1 = require("./downloadFile");
 const downloadFileBatch_1 = require("./downloadFileBatch");
 /**
@@ -132,21 +132,21 @@ function generateStatusSuffixText(downloadStatus, fileQueryData) {
         // Add completed locales
         if (status.completed.size > 0) {
             const completedCodes = Array.from(status.completed)
-                .map((locale) => (0, generaltranslation_1.getLocaleProperties)(locale).code)
+                .map((locale) => generaltranslation_1.default.getLocaleProperties(locale).code)
                 .join(', ');
             localeStatuses.push(chalk_1.default.green(`${completedCodes}`));
         }
         // Add failed locales
         if (status.failed.size > 0) {
             const failedCodes = Array.from(status.failed)
-                .map((locale) => (0, generaltranslation_1.getLocaleProperties)(locale).code)
+                .map((locale) => generaltranslation_1.default.getLocaleProperties(locale).code)
                 .join(', ');
             localeStatuses.push(chalk_1.default.red(`${failedCodes}`));
         }
         // Add pending locales
         if (status.pending.size > 0) {
             const pendingCodes = Array.from(status.pending)
-                .map((locale) => (0, generaltranslation_1.getLocaleProperties)(locale).code)
+                .map((locale) => generaltranslation_1.default.getLocaleProperties(locale).code)
                 .join(', ');
             localeStatuses.push(chalk_1.default.yellow(`${pendingCodes}`));
         }

package/dist/api/waitForUpdates.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitForUpdates = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const console_1 = require("../console");
-const generaltranslation_1 = require("generaltranslation");
+const generaltranslation_1 = __importDefault(require("generaltranslation"));
 /**
  * Waits for translations to be deployed to the General Translation API
  * @param apiKey - The API key for the General Translation API
@@ -47,7 +47,7 @@ const waitForUpdates = async (apiKey, baseUrl, versionId, startTime, timeoutDura
                         chalk_1.default.green(`[${availableLocales.length}/${locales.length}]`) +
                             ` translations completed`,
                         ...availableLocales.map((locale) => {
-                            const localeProperties = (0, generaltranslation_1.getLocaleProperties)(locale);
+                            const localeProperties = generaltranslation_1.default.getLocaleProperties(locale);
                             return `Translation completed for ${chalk_1.default.green(localeProperties.name)} (${chalk_1.default.green(localeProperties.code)})`;
                         }),
                     ];

package/dist/config/validateSettings.js

@@ -1,23 +1,26 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateSettings = validateSettings;
-const generaltranslation_1 = require("generaltranslation");
+const generaltranslation_1 = __importDefault(require("generaltranslation"));
 const console_1 = require("../console");
 function validateSettings(settings) {
     // Validate locales
     for (const locale of settings.locales) {
-        if (!(0, generaltranslation_1.isValidLocale)(locale)) {
+        if (!generaltranslation_1.default.isValidLocale(locale)) {
             (0, console_1.logErrorAndExit)(`Provided locales: "${settings?.locales?.join()}", ${locale} is not a valid locale!`);
         }
     }
-    if (settings.defaultLocale && !(0, generaltranslation_1.isValidLocale)(settings.defaultLocale)) {
+    if (settings.defaultLocale && !generaltranslation_1.default.isValidLocale(settings.defaultLocale)) {
         (0, console_1.logErrorAndExit)(`defaultLocale: ${settings.defaultLocale} is not a valid locale!`);
     }
     // defaultLocale cannot be a superset of any other locale
     if (settings.defaultLocale &&
-        settings.locales.some((locale) => (0, generaltranslation_1.isSupersetLocale)(settings.defaultLocale, locale) &&
-            !(0, generaltranslation_1.isSupersetLocale)(locale, settings.defaultLocale))) {
-        const locale = settings.locales.find((locale) => (0, generaltranslation_1.isSupersetLocale)(settings.defaultLocale, locale));
+        settings.locales.some((locale) => generaltranslation_1.default.isSupersetLocale(settings.defaultLocale, locale) &&
+            !generaltranslation_1.default.isSupersetLocale(locale, settings.defaultLocale))) {
+        const locale = settings.locales.find((locale) => generaltranslation_1.default.isSupersetLocale(settings.defaultLocale, locale));
         (0, console_1.logErrorAndExit)(`defaultLocale: ${settings.defaultLocale} is a superset of another locale (${locale})! Please change the defaultLocale to a more specific locale.`);
     }
 }

package/dist/next/config/parseNextConfig.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseNextConfig = parseNextConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
-const generaltranslation_1 = require("generaltranslation");
+const generaltranslation_1 = __importDefault(require("generaltranslation"));
 const node_path_1 = __importDefault(require("node:path"));
 /**
  * Extracts projectId, defaultLocale, and locales from a next.config.js file.
@@ -42,7 +42,7 @@ async function parseNextConfig(filePath) {
             .filter((locale) => typeof locale === 'string')
         : undefined;
     // Ensure approvedLocales is an array of strings
-    const validLocales = locales && locales.every((locale) => (0, generaltranslation_1.isValidLocale)(locale))
+    const validLocales = locales && locales.every((locale) => generaltranslation_1.default.isValidLocale(locale))
         ? locales
         : undefined;
     // Return the extracted values if they pass type checks or return null

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

@@ -38,7 +38,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.attributes = void 0;
 exports.parseStrings = parseStrings;
-const generaltranslation_1 = require("generaltranslation");
 const t = __importStar(require("@babel/types"));
 const evaluateJsx_1 = require("../evaluateJsx");
 const console_1 = require("../../../console");
@@ -77,8 +76,6 @@ function parseStrings(importName, path, updates, errors, file) {
                             const source = arg.type === 'StringLiteral'
                                 ? arg.value
                                 : arg.quasis[0].value.raw;
-                            // split the string into content (same as runtime behavior)
-                            const content = (0, generaltranslation_1.splitStringToContent)(source);
                             // get metadata and id from options
                             const options = tPath.parent.arguments[1];
                             const metadata = {};
@@ -102,7 +99,7 @@ function parseStrings(importName, path, updates, errors, file) {
                             }
                             updates.push({
                                 dataFormat: 'JSX',
-                                source: content,
+                                source,
                                 metadata,
                             });
                         }

package/dist/react/jsx/utils/parseStringFunction.d.ts

@@ -6,12 +6,12 @@ export declare const attributes: string[];
  *
  * Supports complex patterns including:
  * 1. Direct calls: const t = useGT(); t('hello');
- * 2. Function parameters: const t = useGT(); getInfo(t); where getInfo uses t() internally
- * 3. Cross-file function calls: imported functions that receive t as a parameter
+ * 2. Translation callback prop drilling: const t = useGT(); getInfo(t); where getInfo uses t() internally
+ * 3. Cross-file function calls: imported functions that receive the translation callback as a parameter
  *
  * Example flow:
  * - const t = useGT();
  * - const { home } = getInfo(t); // getInfo is imported from './constants'
- * - This will parse constants.ts to find t() calls within getInfo function
+ * - This will parse constants.ts to find translation calls within getInfo function
  */
 export declare function parseStrings(importName: string, path: NodePath, updates: Updates, errors: string[], file: string): void;

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

@@ -38,7 +38,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.attributes = void 0;
 exports.parseStrings = parseStrings;
-const generaltranslation_1 = require("generaltranslation");
 const t = __importStar(require("@babel/types"));
 const evaluateJsx_1 = require("../evaluateJsx");
 const console_1 = require("../../../console");
@@ -67,8 +66,6 @@ function processTranslationCall(tPath, updates, errors, file) {
         if (arg.type === 'StringLiteral' ||
             (t.isTemplateLiteral(arg) && arg.expressions.length === 0)) {
             const source = arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;
-            // split the string into content (same as runtime behavior)
-            const content = (0, generaltranslation_1.splitStringToContent)(source);
             // get metadata and id from options
             const options = tPath.parent.arguments[1];
             const metadata = {};
@@ -91,7 +88,7 @@ function processTranslationCall(tPath, updates, errors, file) {
             }
             updates.push({
                 dataFormat: 'JSX',
-                source: content,
+                source,
                 metadata,
             });
         }
@@ -105,21 +102,163 @@ function processTranslationCall(tPath, updates, errors, file) {
     }
 }
 /**
- * Finds all usages of a function parameter within a function's scope and processes
- * any translation calls made with that parameter.
+ * Extracts the parameter name from a function parameter node, handling TypeScript annotations.
+ */
+function extractParameterName(param) {
+    if (t.isIdentifier(param)) {
+        return param.name;
+    }
+    return null;
+}
+/**
+ * Builds a map of imported function names to their import paths from a given program path.
+ * Handles both named imports and default imports.
+ *
+ * Example: import { getInfo } from './constants' -> Map { 'getInfo' => './constants' }
+ * Example: import utils from './utils' -> Map { 'utils' => './utils' }
+ */
+function buildImportMap(programPath) {
+    const importMap = new Map();
+    programPath.traverse({
+        ImportDeclaration(importPath) {
+            if (t.isStringLiteral(importPath.node.source)) {
+                const importSource = importPath.node.source.value;
+                importPath.node.specifiers.forEach((spec) => {
+                    if (t.isImportSpecifier(spec) &&
+                        t.isIdentifier(spec.imported) &&
+                        t.isIdentifier(spec.local)) {
+                        importMap.set(spec.local.name, importSource);
+                    }
+                    else if (t.isImportDefaultSpecifier(spec) &&
+                        t.isIdentifier(spec.local)) {
+                        importMap.set(spec.local.name, importSource);
+                    }
+                });
+            }
+        },
+    });
+    return importMap;
+}
+/**
+ * Recursively resolves variable assignments to find all aliases of a translation callback parameter.
+ * Handles cases like: const t = translate; const a = translate; const b = a; const c = b;
+ *
+ * @param scope The scope to search within
+ * @param variableName The variable name to resolve
+ * @param visited Set to track already visited variables to prevent infinite loops
+ * @returns Array of all variable names that reference the original translation callback
+ */
+function resolveVariableAliases(scope, variableName, visited = new Set()) {
+    if (visited.has(variableName)) {
+        return []; // Prevent infinite loops
+    }
+    visited.add(variableName);
+    const aliases = [variableName];
+    const binding = scope.bindings[variableName];
+    if (binding) {
+        // Look for variable declarations that assign this variable to another name
+        // Example: const t = translate; or const a = t;
+        for (const [otherVarName, otherBinding] of Object.entries(scope.bindings)) {
+            if (otherVarName === variableName || visited.has(otherVarName))
+                continue;
+            const otherBindingTyped = otherBinding;
+            if (otherBindingTyped.path &&
+                otherBindingTyped.path.isVariableDeclarator() &&
+                otherBindingTyped.path.node.init &&
+                t.isIdentifier(otherBindingTyped.path.node.init) &&
+                otherBindingTyped.path.node.init.name === variableName) {
+                // Found an alias: const otherVarName = variableName;
+                const nestedAliases = resolveVariableAliases(scope, otherVarName, visited);
+                aliases.push(...nestedAliases);
+            }
+        }
+    }
+    return aliases;
+}
+/**
+ * Handles how translation callbacks are used within code.
+ * This covers both direct translation calls (t('hello')) and prop drilling
+ * where the translation callback is passed to other functions (getData(t)).
+ */
+function handleFunctionCall(tPath, updates, errors, file, importMap) {
+    if (tPath.parent.type === 'CallExpression' &&
+        tPath.parent.callee === tPath.node) {
+        // Direct translation call: t('hello')
+        processTranslationCall(tPath, updates, errors, file);
+    }
+    else if (tPath.parent.type === 'CallExpression' &&
+        t.isExpression(tPath.node) &&
+        tPath.parent.arguments.includes(tPath.node)) {
+        // Parameter passed to another function: getData(t)
+        const argIndex = tPath.parent.arguments.indexOf(tPath.node);
+        const callee = tPath.parent.callee;
+        if (t.isIdentifier(callee)) {
+            const calleeBinding = tPath.scope.getBinding(callee.name);
+            if (calleeBinding && calleeBinding.path.isFunction()) {
+                const functionPath = calleeBinding.path;
+                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file);
+            }
+            // Handle arrow functions assigned to variables: const getData = (t) => {...}
+            else if (calleeBinding &&
+                calleeBinding.path.isVariableDeclarator() &&
+                calleeBinding.path.node.init &&
+                (t.isArrowFunctionExpression(calleeBinding.path.node.init) ||
+                    t.isFunctionExpression(calleeBinding.path.node.init))) {
+                const initPath = calleeBinding.path.get('init');
+                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file);
+            }
+            // If not found locally, check if it's an imported function
+            else if (importMap.has(callee.name)) {
+                const importPath = importMap.get(callee.name);
+                const resolvedPath = resolveImportPath(file, importPath);
+                if (resolvedPath) {
+                    findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors);
+                }
+            }
+        }
+    }
+}
+/**
+ * Processes a user-defined function that receives a translation callback as a parameter.
+ * Validates the function has enough parameters and traces how the translation callback
+ * is used within that function's body.
+ */
+function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath) {
+    if (functionNode.params.length > argIndex) {
+        const param = functionNode.params[argIndex];
+        const paramName = extractParameterName(param);
+        if (paramName) {
+            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath);
+        }
+    }
+}
+/**
+ * Finds all usages of a translation callback parameter within a user-defined function's scope.
+ * Processes both direct translation calls and cases where the translation callback is passed
+ * to other functions (prop drilling).
  *
  * Example: In function getInfo(t) { return t('hello'); }, this finds the t('hello') call.
+ * Example: In function getData(t) { return getFooter(t); }, this finds and traces into getFooter.
  */
 function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file) {
     // Look for the function body and find all usages of the parameter
     if (functionPath.isFunction()) {
         const functionScope = functionPath.scope;
-        const binding = functionScope.bindings[parameterName];
-        if (binding) {
-            binding.referencePaths.forEach((refPath) => {
-                processTranslationCall(refPath, updates, errors, file);
-            });
-        }
+        // Resolve all aliases of the translation callback parameter
+        // Example: translate -> [translate, t, a, b] for const t = translate; const a = t; const b = a;
+        const allParameterNames = resolveVariableAliases(functionScope, parameterName);
+        // Build import map for this function's scope to handle cross-file calls
+        const programPath = functionPath.scope.getProgramParent().path;
+        const importMap = buildImportMap(programPath);
+        // Process references for all parameter names and their aliases
+        allParameterNames.forEach((name) => {
+            const binding = functionScope.bindings[name];
+            if (binding) {
+                binding.referencePaths.forEach((refPath) => {
+                    handleFunctionCall(refPath, updates, errors, file, importMap);
+                });
+            }
+        });
     }
 }
 /**
@@ -164,12 +303,31 @@ function resolveImportPath(currentFile, importPath) {
         return resolve.sync(importPath, { basedir, extensions });
     }
     catch {
+        // If resolution fails, try to manually replace .js/.jsx with .ts/.tsx for source files
+        if (importPath.endsWith('.js')) {
+            const tsPath = importPath.replace(/\.js$/, '.ts');
+            try {
+                return resolve.sync(tsPath, { basedir, extensions });
+            }
+            catch {
+                // Continue to return null
+            }
+        }
+        else if (importPath.endsWith('.jsx')) {
+            const tsxPath = importPath.replace(/\.jsx$/, '.tsx');
+            try {
+                return resolve.sync(tsxPath, { basedir, extensions });
+            }
+            catch {
+                // Continue to return null
+            }
+        }
         return null;
     }
 }
 /**
- * Searches for a specific function in a file and analyzes how a particular parameter
- * (at argIndex position) is used within that function for translation calls.
+ * Searches for a specific user-defined function in a file and analyzes how a translation callback
+ * parameter (at argIndex position) is used within that function.
  *
  * Handles multiple function declaration patterns:
  * - function getInfo(t) { ... }
@@ -186,25 +344,8 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
         (0, traverse_1.default)(ast, {
             // Handle function declarations: function getInfo(t) { ... }
             FunctionDeclaration(path) {
-                if (path.node.id?.name === functionName &&
-                    path.node.params.length > argIndex) {
-                    const param = path.node.params[argIndex];
-                    if (t.isIdentifier(param)) {
-                        findFunctionParameterUsage(path, param.name, updates, errors, filePath);
-                    }
-                }
-            },
-            // Handle exported function declarations: export function getInfo(t) { ... }
-            ExportNamedDeclaration(path) {
-                if (path.node.declaration &&
-                    t.isFunctionDeclaration(path.node.declaration)) {
-                    const func = path.node.declaration;
-                    if (func.id?.name === functionName && func.params.length > argIndex) {
-                        const param = func.params[argIndex];
-                        if (t.isIdentifier(param)) {
-                            findFunctionParameterUsage(path.get('declaration'), param.name, updates, errors, filePath);
-                        }
-                    }
+                if (path.node.id?.name === functionName) {
+                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath);
                 }
             },
             // Handle variable declarations: const getInfo = (t) => { ... }
@@ -213,13 +354,9 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
                     path.node.id.name === functionName &&
                     path.node.init &&
                     (t.isArrowFunctionExpression(path.node.init) ||
-                        t.isFunctionExpression(path.node.init)) &&
-                    path.node.init.params.length > argIndex) {
-                    const param = path.node.init.params[argIndex];
-                    if (t.isIdentifier(param)) {
-                        const initPath = path.get('init');
-                        findFunctionParameterUsage(initPath, param.name, updates, errors, filePath);
-                    }
+                        t.isFunctionExpression(path.node.init))) {
+                    const initPath = path.get('init');
+                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath);
                 }
             },
         });
@@ -233,35 +370,17 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
  *
  * Supports complex patterns including:
  * 1. Direct calls: const t = useGT(); t('hello');
- * 2. Function parameters: const t = useGT(); getInfo(t); where getInfo uses t() internally
- * 3. Cross-file function calls: imported functions that receive t as a parameter
+ * 2. Translation callback prop drilling: const t = useGT(); getInfo(t); where getInfo uses t() internally
+ * 3. Cross-file function calls: imported functions that receive the translation callback as a parameter
  *
  * Example flow:
  * - const t = useGT();
  * - const { home } = getInfo(t); // getInfo is imported from './constants'
- * - This will parse constants.ts to find t() calls within getInfo function
+ * - This will parse constants.ts to find translation calls within getInfo function
  */
 function parseStrings(importName, path, updates, errors, file) {
     // First, collect all imports in this file to track cross-file function calls
-    const importMap = new Map(); // functionName -> importPath
-    path.scope.getProgramParent().path.traverse({
-        ImportDeclaration(importPath) {
-            if (t.isStringLiteral(importPath.node.source)) {
-                const importSource = importPath.node.source.value;
-                importPath.node.specifiers.forEach((spec) => {
-                    if (t.isImportSpecifier(spec) &&
-                        t.isIdentifier(spec.imported) &&
-                        t.isIdentifier(spec.local)) {
-                        importMap.set(spec.local.name, importSource);
-                    }
-                    else if (t.isImportDefaultSpecifier(spec) &&
-                        t.isIdentifier(spec.local)) {
-                        importMap.set(spec.local.name, importSource);
-                    }
-                });
-            }
-        },
-    });
+    const importMap = buildImportMap(path.scope.getProgramParent().path);
     const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
     for (const refPath of referencePaths) {
         // Find call expressions of useGT() / await getGT()
@@ -280,40 +399,7 @@ function parseStrings(importName, path, updates, errors, file) {
                 const variableScope = effectiveParent.scope;
                 const tReferencePaths = variableScope.bindings[tFuncName]?.referencePaths || [];
                 for (const tPath of tReferencePaths) {
-                    // Check if this is a direct call to the translation function
-                    if (tPath.parent.type === 'CallExpression' &&
-                        tPath.parent.callee === tPath.node) {
-                        processTranslationCall(tPath, updates, errors, file);
-                    }
-                    // Check if this is being passed as an argument to another function
-                    else if (tPath.parent.type === 'CallExpression' &&
-                        t.isExpression(tPath.node) &&
-                        tPath.parent.arguments.includes(tPath.node)) {
-                        // Find which parameter position this is
-                        const argIndex = tPath.parent.arguments.indexOf(tPath.node);
-                        // Try to find the function definition being called
-                        const callee = tPath.parent.callee;
-                        if (t.isIdentifier(callee)) {
-                            // Look for function declarations or function expressions with this name
-                            const calleeBinding = tPath.scope.getBinding(callee.name);
-                            if (calleeBinding && calleeBinding.path.isFunction()) {
-                                const functionPath = calleeBinding.path;
-                                const params = functionPath.node.params;
-                                if (params[argIndex] && t.isIdentifier(params[argIndex])) {
-                                    const paramName = params[argIndex].name;
-                                    findFunctionParameterUsage(functionPath, paramName, updates, errors, file);
-                                }
-                            }
-                            // If not found locally, check if it's an imported function
-                            else if (importMap.has(callee.name)) {
-                                const importPath = importMap.get(callee.name);
-                                const resolvedPath = resolveImportPath(file, importPath);
-                                if (resolvedPath) {
-                                    findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors);
-                                }
-                            }
-                        }
-                    }
+                    handleFunctionCall(tPath, updates, errors, file, importMap);
                 }
             }
         }

package/dist/react/parse/createDictionaryUpdates.js

@@ -9,7 +9,6 @@ const node_path_1 = __importDefault(require("node:path"));
 const os_1 = __importDefault(require("os"));
 const esbuild_1 = require("esbuild");
 const flattenDictionary_1 = __importDefault(require("../utils/flattenDictionary"));
-const generaltranslation_1 = require("generaltranslation");
 const loadJSON_1 = __importDefault(require("../../fs/loadJSON"));
 const id_1 = require("generaltranslation/id");
 const getEntryAndMetadata_1 = __importDefault(require("../utils/getEntryAndMetadata"));
@@ -55,14 +54,13 @@ async function createDictionaryUpdates(options, dictionaryPath, esbuildConfig) {
     for (const id of Object.keys(dictionary)) {
         const { entry, metadata: props, // context, etc.
          } = (0, getEntryAndMetadata_1.default)(dictionary[id]);
-        const source = (0, generaltranslation_1.splitStringToContent)(entry);
         const context = props?.context;
         const metadata = {
             id,
             ...(context && { context }),
             // This hash isn't actually used by the GT API, just for consistency sake
             hash: (0, id_1.hashJsxChildren)({
-                source,
+                source: entry,
                 ...(context && { context }),
                 ...(id && { id }),
                 dataFormat: 'JSX',
@@ -70,7 +68,7 @@ async function createDictionaryUpdates(options, dictionaryPath, esbuildConfig) {
         };
         updates.push({
             dataFormat: 'JSX',
-            source,
+            source: entry,
             metadata,
         });
     }

package/dist/setup/userInput.js

@@ -7,7 +7,7 @@ exports.getDesiredLocales = getDesiredLocales;
 const internal_1 = require("generaltranslation/internal");
 const console_1 = require("../console");
 const chalk_1 = __importDefault(require("chalk"));
-const generaltranslation_1 = require("generaltranslation");
+const generaltranslation_1 = __importDefault(require("generaltranslation"));
 async function getDesiredLocales() {
     // Ask for the default locale
     const defaultLocale = await (0, console_1.promptText)({
@@ -24,7 +24,7 @@ async function getDesiredLocales() {
                 return 'Please enter at least one locale';
             }
             for (const locale of localeList) {
-                if (!(0, generaltranslation_1.isValidLocale)(locale)) {
+                if (!generaltranslation_1.default.isValidLocale(locale)) {
                     return 'Please enter a valid locale (e.g., en, fr, es)';
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "1.2.22",
+  "version": "1.2.24-alpha.0",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -79,7 +79,7 @@
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.2",
-    "generaltranslation": "^6.2.10",
+    "generaltranslation": "^7.0.0-alpha.0",
     "open": "^10.1.1",
     "ora": "^8.2.0",
     "resolve": "^1.22.10",