gt 2.14.31 → 2.14.32

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # gtx-cli
 
+## 2.14.32
+
+### Patch Changes
+
+- [#1338](https://github.com/generaltranslation/gt/pull/1338) [`66b5df5`](https://github.com/generaltranslation/gt/commit/66b5df57a69d224345ad0a6191437ba8aca3a19d) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - Generate explicit relative import paths in `loadTranslations.js` for local
+  translation files.
+
+- [#1314](https://github.com/generaltranslation/gt/pull/1314) [`a13629f`](https://github.com/generaltranslation/gt/commit/a13629f2c5e5a2fcc22c34704507bcc591174825) Thanks [@bgub](https://github.com/bgub)! - Show a warning download status when completed files are missing from the download response.
+
 ## 2.14.31
 
 ### Patch Changes

package/dist/config/generateSettings.js

@@ -142,9 +142,7 @@ export async function generateSettings(flags, cwd = process.cwd(), options) {
     // Don't default src here — each pipeline (JS/Python) has its own defaults.
     // Only set src if the user explicitly provided it via flags or config.
     // Resolve all glob patterns in the files object
-    const compositePatterns = [
-        ...Object.entries(mergedOptions.options?.jsonSchema || {}),
-    ]
+    const compositePatterns = Object.entries(mergedOptions.options?.jsonSchema || {})
         .filter(([, schema]) => schema.composite)
         .map(([key]) => key);
     mergedOptions.files = mergedOptions.files
@@ -162,9 +160,9 @@ export async function generateSettings(flags, cwd = process.cwd(), options) {
             },
         };
     mergedOptions.options = {
-        ...(mergedOptions.options || {}),
+        ...mergedOptions.options,
         mintlify: {
-            ...(mergedOptions.options?.mintlify || {}),
+            ...mergedOptions.options?.mintlify,
             inferTitleFromFilename: gtConfig.options?.mintlify?.inferTitleFromFilename ||
                 mergedOptions.options?.mintlify?.inferTitleFromFilename,
         },

package/dist/console/logging.js

@@ -7,6 +7,7 @@ import { TEMPLATE_FILE_NAME } from '../utils/constants.js';
  * Strip ANSI escape codes from a string (e.g., chalk color codes)
  */
 export function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex, no-useless-escape
     return str.replace(/\x1B\[[0-9;]*m/g, '');
 }
 export function logErrorAndExit(message) {
@@ -27,6 +28,7 @@ export function displayHeader(introString) {
     }
 }
 function displayAsciiTitle() {
+    // eslint-disable-next-line no-console
     console.log(chalk.cyan(`\n  ,ad8888ba,  888888888888  
  d8"'    \`"8b      88       
 d8'                88       
@@ -38,6 +40,7 @@ Y8,        88      88
 }
 function displayInitializingText() {
     const version = getCLIVersion();
+    // eslint-disable-next-line no-console
     console.log(`\n${chalk.bold.blue('General Translation, Inc.')}
 ${chalk.dim('https://generaltranslation.com/docs')}
 ${chalk.dim(`CLI Version: ${version}\n`)}`);

package/dist/formats/json/utils.js

@@ -147,17 +147,14 @@ export function validateJsonSchema(options, filePath) {
     if (jsonSchema.include && jsonSchema.composite) {
         logger.error('include and composite cannot be used together in the same JSON schema');
         return exitSync(1);
-        return null;
     }
     if (!jsonSchema.include && !jsonSchema.composite) {
         logger.error('No include or composite property found in JSON schema');
         return exitSync(1);
-        return null;
     }
     if (jsonSchema.structuralTransform && !jsonSchema.composite) {
         logger.error('structuralTransform requires composite to be defined in the JSON schema');
         return exitSync(1);
-        return null;
     }
     return jsonSchema;
 }

package/dist/fs/createLoadTranslationsFile.js

@@ -3,14 +3,27 @@ import path from 'node:path';
 import { logger } from '../console/logger.js';
 import chalk from 'chalk';
 import { DEFAULT_TRANSLATIONS_DIR } from '../utils/constants.js';
+function toRelativeImportPath(relativePath) {
+    const normalizedPath = relativePath.split(path.sep).join(path.posix.sep);
+    if (!normalizedPath) {
+        return './';
+    }
+    // Dynamic imports must use explicit relative specifiers; values like
+    // "src/_gt" are otherwise treated as package names by Vite and Node.
+    const hasExplicitRelativePrefix = normalizedPath === '..' ||
+        normalizedPath.startsWith('../') ||
+        normalizedPath.startsWith('./');
+    return hasExplicitRelativePrefix
+        ? `${normalizedPath}/`
+        : `./${normalizedPath}/`;
+}
 export async function createLoadTranslationsFile(appDirectory, translationsDir = DEFAULT_TRANSLATIONS_DIR, locales) {
     const usingSrcDirectory = fs.existsSync(path.join(appDirectory, 'src'));
-    // Calculate the relative path from the loadTranslations.js location to the translations directory
     const loadTranslationsDir = usingSrcDirectory
         ? path.join(appDirectory, 'src')
         : appDirectory;
     const relativePath = path.relative(loadTranslationsDir, path.resolve(appDirectory, translationsDir));
-    const publicPath = relativePath ? `${relativePath}/` : './';
+    const publicPath = toRelativeImportPath(relativePath);
     const filePath = usingSrcDirectory
         ? path.join(appDirectory, 'src', 'loadTranslations.js')
         : path.join(appDirectory, 'loadTranslations.js');

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.14.31";
+export declare const PACKAGE_VERSION = "2.14.32";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const PACKAGE_VERSION = '2.14.31';
+export const PACKAGE_VERSION = '2.14.32';

package/dist/react/jsx/utils/jsxParsing/removeNullChildrenFields.js

@@ -31,12 +31,10 @@ export function removeNullChildrenFields(tree) {
         if (child && 'd' in child && child.d != null) {
             let b;
             if (child.d && 'b' in child.d && child.d.b != null) {
-                b = {
-                    ...Object.fromEntries(Object.entries(child.d.b).map(([key, value]) => [
-                        key,
-                        handleChildren(value),
-                    ])),
-                };
+                b = Object.fromEntries(Object.entries(child.d.b).map(([key, value]) => [
+                    key,
+                    handleChildren(value),
+                ]));
             }
             d = {
                 ...(b != null && { b }),

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

@@ -49,7 +49,7 @@ function unwrapTypeAnnotation(node) {
  * Collects all resolvable property entries from an ObjectExpression,
  * including entries from spread sources.
  */
-function collectObjectProperties(objExpr, tPath, file, parsingOptions, warnings, errors = []) {
+function collectObjectProperties(objExpr, tPath, file, parsingOptions, errors = []) {
     const entries = [];
     for (const prop of objExpr.properties) {
         if (t.isObjectProperty(prop)) {
@@ -68,7 +68,7 @@ function collectObjectProperties(objExpr, tPath, file, parsingOptions, warnings,
             // Handle inline ObjectExpression spread: { ...({ a: 'x' }) }
             const spreadArg = unwrapTypeAnnotation(prop.argument);
             if (t.isObjectExpression(spreadArg)) {
-                entries.push(...collectObjectProperties(spreadArg, tPath, file, parsingOptions, warnings, errors));
+                entries.push(...collectObjectProperties(spreadArg, tPath, file, parsingOptions, errors));
                 continue;
             }
             if (!t.isIdentifier(prop.argument))
@@ -96,7 +96,7 @@ function collectObjectProperties(objExpr, tPath, file, parsingOptions, warnings,
                     resolvingIdentifiers.delete(spreadInit);
                     continue;
                 }
-                entries.push(...collectObjectProperties(spreadObj, spreadBinding.path, file, parsingOptions, warnings, errors));
+                entries.push(...collectObjectProperties(spreadObj, spreadBinding.path, file, parsingOptions, errors));
                 resolvingIdentifiers.delete(spreadInit);
             }
             // Cross-file: ImportSpecifier or ImportDefaultSpecifier
@@ -117,11 +117,11 @@ function collectObjectProperties(objExpr, tPath, file, parsingOptions, warnings,
                 const resolvedFilePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
                 if (!resolvedFilePath)
                     continue;
-                const crossFileObjects = resolveObjectNodesInFile(resolvedFilePath, originalName, parsingOptions, warnings);
+                const crossFileObjects = resolveObjectNodesInFile(resolvedFilePath, originalName, parsingOptions);
                 for (const crossObj of crossFileObjects) {
                     const crossEntries = t.isArrayExpression(crossObj.objExpr)
-                        ? collectArrayElements(crossObj.objExpr, crossObj.tPath, crossObj.file, parsingOptions, warnings)
-                        : collectObjectProperties(crossObj.objExpr, crossObj.tPath, crossObj.file, parsingOptions, warnings, errors);
+                        ? collectArrayElements(crossObj.objExpr, crossObj.tPath, crossObj.file, parsingOptions)
+                        : collectObjectProperties(crossObj.objExpr, crossObj.tPath, crossObj.file, parsingOptions, errors);
                     entries.push(...crossEntries);
                 }
             }
@@ -134,7 +134,7 @@ function collectObjectProperties(objExpr, tPath, file, parsingOptions, warnings,
  * Collects elements from an ArrayExpression as ObjectEntry[] with index as key.
  * Handles spread elements by resolving the source array.
  */
-function collectArrayElements(arrExpr, tPath, file, parsingOptions, warnings, errors = []) {
+function collectArrayElements(arrExpr, tPath, file, parsingOptions, errors = []) {
     const entries = [];
     let index = 0;
     for (const el of arrExpr.elements) {
@@ -162,7 +162,7 @@ function collectArrayElements(arrExpr, tPath, file, parsingOptions, warnings, er
                     continue;
                 const spreadUnwrapped = unwrapTypeAnnotation(spreadInit);
                 if (t.isArrayExpression(spreadUnwrapped)) {
-                    const spreadEntries = collectArrayElements(spreadUnwrapped, spreadBinding.path, file, parsingOptions, warnings);
+                    const spreadEntries = collectArrayElements(spreadUnwrapped, spreadBinding.path, file, parsingOptions);
                     for (const e of spreadEntries) {
                         entries.push({ key: String(index++), value: e.value });
                     }
@@ -187,10 +187,10 @@ function collectArrayElements(arrExpr, tPath, file, parsingOptions, warnings, er
                 const resolvedFilePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
                 if (!resolvedFilePath)
                     continue;
-                const crossFileNodes = resolveObjectNodesInFile(resolvedFilePath, originalName, parsingOptions, warnings);
+                const crossFileNodes = resolveObjectNodesInFile(resolvedFilePath, originalName, parsingOptions);
                 for (const crossNode of crossFileNodes) {
                     if (t.isArrayExpression(crossNode.objExpr)) {
-                        const spreadEntries = collectArrayElements(crossNode.objExpr, crossNode.tPath, crossNode.file, parsingOptions, warnings);
+                        const spreadEntries = collectArrayElements(crossNode.objExpr, crossNode.tPath, crossNode.file, parsingOptions);
                         for (const e of spreadEntries) {
                             entries.push({ key: String(index++), value: e.value });
                         }
@@ -275,7 +275,7 @@ function resolveToObjectNodes(node, tPath, file, parsingOptions, warnings, error
             const resolvedFilePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
             if (!resolvedFilePath)
                 return [];
-            return resolveObjectNodesInFile(resolvedFilePath, originalName, parsingOptions, warnings);
+            return resolveObjectNodesInFile(resolvedFilePath, originalName, parsingOptions);
         }
         return [];
     }
@@ -289,8 +289,8 @@ function resolveToObjectNodes(node, tPath, file, parsingOptions, warnings, error
         const results = [];
         for (const parent of parentObjects) {
             const entries = t.isArrayExpression(parent.objExpr)
-                ? collectArrayElements(parent.objExpr, parent.tPath, parent.file, parsingOptions, warnings)
-                : collectObjectProperties(parent.objExpr, parent.tPath, parent.file, parsingOptions, warnings, errors);
+                ? collectArrayElements(parent.objExpr, parent.tPath, parent.file, parsingOptions)
+                : collectObjectProperties(parent.objExpr, parent.tPath, parent.file, parsingOptions, errors);
             // Determine if this is a static access (known key)
             let staticKey = null;
             if (!node.computed && t.isIdentifier(node.property)) {
@@ -342,7 +342,7 @@ function resolveToObjectNodes(node, tPath, file, parsingOptions, warnings, error
  * Finds a const VariableDeclarator with ObjectExpression init.
  * Follows re-export chains.
  */
-function resolveObjectNodesInFile(filePath, name, parsingOptions, warnings) {
+function resolveObjectNodesInFile(filePath, name, parsingOptions) {
     const cacheKey = `${filePath}::${name}`;
     if (resolveObjectNodeCache.has(cacheKey)) {
         return resolveObjectNodeCache.get(cacheKey);
@@ -384,7 +384,7 @@ function resolveObjectNodesInFile(filePath, name, parsingOptions, warnings) {
                     const reexportPath = path.node.source.value;
                     const resolvedPath = resolveImportPath(filePath, reexportPath, parsingOptions, resolveImportPathCache);
                     if (resolvedPath) {
-                        results.push(...resolveObjectNodesInFile(resolvedPath, name, parsingOptions, warnings));
+                        results.push(...resolveObjectNodesInFile(resolvedPath, name, parsingOptions));
                     }
                 }
             },
@@ -420,7 +420,7 @@ function resolveObjectNodesInFile(filePath, name, parsingOptions, warnings) {
                                 t.isIdentifier(specifier.local)) {
                                 originalName = specifier.local.name;
                             }
-                            results.push(...resolveObjectNodesInFile(resolvedPath, originalName, parsingOptions, warnings));
+                            results.push(...resolveObjectNodesInFile(resolvedPath, originalName, parsingOptions));
                         }
                     }
                 }
@@ -594,8 +594,8 @@ export function parseStringExpression(node, tPath, file, parsingOptions, warning
         const branches = [];
         for (const { objExpr, tPath: objPath, file: objFile } of objectNodes) {
             const entries = t.isArrayExpression(objExpr)
-                ? collectArrayElements(objExpr, objPath, objFile, parsingOptions, warnings, errors)
-                : collectObjectProperties(objExpr, objPath, objFile, parsingOptions, warnings, errors);
+                ? collectArrayElements(objExpr, objPath, objFile, parsingOptions, errors)
+                : collectObjectProperties(objExpr, objPath, objFile, parsingOptions, errors);
             // Check for static literal subscripts: obj['key'] or obj[0]
             let staticLiteralKey = null;
             if (node.computed && t.isStringLiteral(node.property)) {

package/dist/utils/credentials.js

@@ -15,7 +15,7 @@ export async function retrieveCredentials(settings, keyType) {
     logger.message(`${chalk.dim(`If the browser window didn't open automatically, please open the following link:`)}\n\n${chalk.cyan(urlToOpen)}`);
     const spinner = logger.createSpinner('dots');
     spinner.start('Waiting for response from dashboard...');
-    const credentials = await new Promise(async (resolve) => {
+    const credentials = await new Promise((resolve) => {
         const interval = setInterval(async () => {
             // Ping the dashboard to see if the credentials are set
             try {

package/dist/workflows/steps/DownloadStep.js

@@ -15,15 +15,7 @@ export class DownloadTranslationsStep extends WorkflowStep {
     async run({ fileTracker, resolveOutputPath, forceDownload, }) {
         this.spinner = logger.createProgressBar(fileTracker.completed.size);
         this.spinner.start('Downloading files...');
-        // Download ready files
-        const success = await this.downloadFiles(fileTracker, resolveOutputPath, forceDownload);
-        if (success) {
-            this.spinner.stop(chalk.green('Downloaded files successfully'));
-        }
-        else {
-            this.spinner.stop(chalk.red('Failed to download files'));
-        }
-        return success;
+        return this.downloadFiles(fileTracker, resolveOutputPath, forceDownload);
     }
     async downloadFiles(fileTracker, resolveOutputPath, forceDownload) {
         try {
@@ -31,6 +23,7 @@ export class DownloadTranslationsStep extends WorkflowStep {
             const currentQueryData = Array.from(fileTracker.completed.values());
             // If no files to download, we're done
             if (currentQueryData.length === 0) {
+                this.spinner?.stop(chalk.green('No files to download'));
                 return true;
             }
             // Check for translations
@@ -45,9 +38,11 @@ export class DownloadTranslationsStep extends WorkflowStep {
             const translatedFiles = responseData.translatedFiles || [];
             // Filter for ready translations
             const readyTranslations = translatedFiles.filter((file) => file.completedAt !== null);
+            let missingCount = 0;
             if (readyTranslations.length < currentQueryData.length) {
                 const readyKeys = new Set(readyTranslations.map((t) => `${t.branchId}:${t.fileId}:${t.versionId}:${t.locale}`));
                 const missing = currentQueryData.filter((item) => !readyKeys.has(`${item.branchId}:${item.fileId}:${item.versionId}:${item.locale}`));
+                missingCount = missing.length;
                 logger.warn(`Failed to download ${missing.length} file(s):\n${missing.map((f) => `- ${f.fileName} (${f.locale})`).join('\n')}`);
                 for (const f of missing) {
                     recordWarning('failed_download', f.fileName, `Failed to download for locale ${f.locale}`);
@@ -88,6 +83,9 @@ export class DownloadTranslationsStep extends WorkflowStep {
                     }
                 }
             }
+            else if (missingCount > 0) {
+                this.spinner?.stop(chalk.yellow('No files downloaded - see warnings above'));
+            }
             else {
                 this.spinner?.stop(chalk.green('No files to download'));
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.14.31",
+  "version": "2.14.32",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -148,8 +148,6 @@
     "build:bin:linux-x64": "sh scripts/build-exe.sh linux-x64",
     "build:bin:linux-arm64": "sh scripts/build-exe.sh linux-arm64",
     "build:bin:windows-x64": "sh scripts/build-exe.sh windows-x64",
-    "lint": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\"",
-    "lint:fix": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\" --fix",
     "test": "vitest run --config=./vitest.config.ts",
     "test:watch": "vitest --config=./vitest.config.ts",
     "release": "pnpm run release:normal && pnpm run release:bin",