gtx-cli 2.4.10 → 2.4.12

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.4.12
+
+### Patch Changes
+
+- [#782](https://github.com/generaltranslation/gt/pull/782) [`155fc2c`](https://github.com/generaltranslation/gt/commit/155fc2c987078b2ffc12c55abb65bb7ff16eb09b) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - fix: only throw errors in development for invalid icu strings
+
+## 2.4.11
+
+### Patch Changes
+
+- [#780](https://github.com/generaltranslation/gt/pull/780) [`c048320`](https://github.com/generaltranslation/gt/commit/c048320ae0daf91bebf65145aba6fb15c2f3612d) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - Fix CLI parsing for nbsp characters
+
 ## 2.4.10
 
 ### Patch Changes

package/dist/console/index.d.ts

@@ -3,6 +3,7 @@ export declare const warnVariablePropSync: (file: string, attrName: string, valu
 export declare const warnHasUnwrappedExpressionSync: (file: string, unwrappedExpressions: string[], id?: string, location?: string) => string;
 export declare const warnNestedTComponent: (file: string, location?: string) => string;
 export declare const warnNonStaticExpressionSync: (file: string, attrName: string, value: string, location?: string) => string;
+export declare const warnInvalidIcuSync: (file: string, value: string, error: string, location?: string) => string;
 export declare const warnTemplateLiteralSync: (file: string, value: string, location?: string) => string;
 export declare const warnNonStringSync: (file: string, value: string, location?: string) => string;
 export declare const warnAsyncUseGT: (file: string, location?: string) => string;

package/dist/console/index.js

@@ -5,12 +5,14 @@ export const warnVariablePropSync = (file, attrName, value, location) => withLoc
 export const warnHasUnwrappedExpressionSync = (file, unwrappedExpressions, id, location) => withLocation(file, `${colorizeComponent('<T>')} component${id ? ` with id ${colorizeIdString(id)}` : ''} has children that could change at runtime. Use a variable component like ${colorizeComponent('<Var>')} to ensure this content is translated.\n${colorizeContent(unwrappedExpressions.join('\n'))}`, location);
 export const warnNestedTComponent = (file, location) => withLocation(file, `Found nested <T> component. <T> components cannot be directly nested.`, location);
 export const warnNonStaticExpressionSync = (file, attrName, value, location) => withLocation(file, `Found non-static expression for attribute ${colorizeIdString(attrName)}: ${colorizeContent(value)}. Change "${colorizeIdString(attrName)}" to ensure this content is translated.`, location);
+export const warnInvalidIcuSync = (file, value, error, location) => withWillErrorInNextVersion(withLocation(file, `Found invalid ICU string: ${colorizeContent(value)}. Change the value to a valid ICU to ensure this content is translated. Error message: ${error}.`, location));
 export const warnTemplateLiteralSync = (file, value, location) => withLocation(file, `Found template literal with quasis (${colorizeContent(value)}). Change the template literal to a string to ensure this content is translated.`, location);
 export const warnNonStringSync = (file, value, location) => withLocation(file, `Found non-string literal (${colorizeContent(value)}). Change the value to a string literal to ensure this content is translated.`, location);
 export const warnAsyncUseGT = (file, location) => withLocation(file, `Found useGT() in an async function. Use getGT() instead, or make the function synchronous.`, location);
 export const warnSyncGetGT = (file, location) => withLocation(file, `Found getGT() in a synchronous function. Use useGT() instead, or make the function async.`, location);
 export const warnTernarySync = (file, location) => withLocation(file, 'Found ternary expression. A Branch component may be more appropriate here.', location);
 export const withLocation = (file, message, location) => `${colorizeFilepath(file)}${location ? ` (${colorizeLine(location)})` : ''}: ${message}`;
+const withWillErrorInNextVersion = (message) => `${message} (This will become an error in the next major version of the CLI.)`;
 // Re-export error messages
 export const noLocalesError = `No locales found! Please provide a list of locales to translate to, or specify them in your gt.config.json file.`;
 export const noDefaultLocaleError = `No default locale found! Please provide a default locale, or specify it in your gt.config.json file.`;

package/dist/react/jsx/evaluateJsx.d.ts

@@ -15,3 +15,7 @@ export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpres
     value?: string;
 };
 export declare function isStaticValue(expr: t.Expression | t.JSXEmptyExpression): boolean;
+export declare function isValidIcu(string: string): {
+    isValid: boolean;
+    error?: string;
+};

package/dist/react/jsx/evaluateJsx.js

@@ -1,4 +1,5 @@
 import * as t from '@babel/types';
+import { parse } from '@formatjs/icu-messageformat-parser';
 import generateModule from '@babel/generator';
 // Handle CommonJS/ESM interop
 const generate = generateModule.default || generateModule;
@@ -83,3 +84,15 @@ export function isStaticValue(expr) {
     }
     return false;
 }
+export function isValidIcu(string) {
+    try {
+        parse(string);
+    }
+    catch (error) {
+        return {
+            isValid: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    return { isValid: true };
+}

package/dist/react/jsx/trimJsxStringChildren.js

@@ -1,14 +1,41 @@
 import { isAcceptedPluralForm } from 'generaltranslation/internal';
+// JSX whitespace characters (space, tab, newline, carriage return)
+// Does NOT include non-breaking space (U+00A0) which should be preserved
+const isJsxWhitespace = (char) => {
+    return char === ' ' || char === '\t' || char === '\n' || char === '\r';
+};
+const trimJsxWhitespace = (str, side = 'both') => {
+    let start = 0;
+    let end = str.length;
+    if (side === 'start' || side === 'both') {
+        while (start < end && isJsxWhitespace(str[start])) {
+            start++;
+        }
+    }
+    if (side === 'end' || side === 'both') {
+        while (end > start && isJsxWhitespace(str[end - 1])) {
+            end--;
+        }
+    }
+    return str.slice(start, end);
+};
+const hasNonJsxWhitespace = (str) => {
+    for (const char of str) {
+        if (!isJsxWhitespace(char))
+            return true;
+    }
+    return false;
+};
 export function trimJsxStringChild(child, index, childrenTypes) {
     // Normalize line endings to \n for consistency across platforms
     let result = child.replace(/\r\n|\r/g, '\n');
-    // Collapse multiple spaces/tabs into a single space
+    // Collapse multiple spaces/tabs into a single space (but not nbsp)
     result = result.replace(/[\t ]+/g, ' ');
     let newResult = '';
     let newline = false;
     for (const char of result) {
         if (char === '\n') {
-            if (newResult.trim())
+            if (hasNonJsxWhitespace(newResult))
                 newResult += ' ';
             else
                 newResult = '';
@@ -19,15 +46,15 @@ export function trimJsxStringChild(child, index, childrenTypes) {
             newResult += char;
             continue;
         }
-        if (char.trim() === '')
+        if (isJsxWhitespace(char))
             continue;
         newResult += char;
         newline = false;
     }
     if (newline)
-        newResult = newResult.trimEnd();
+        newResult = trimJsxWhitespace(newResult, 'end');
     result = newResult;
-    // Collapse multiple spaces/tabs into a single space
+    // Collapse multiple spaces/tabs into a single space (but not nbsp)
     result = result.replace(/[\t ]+/g, ' ');
     return result;
 }

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

@@ -18,4 +18,4 @@ export declare function clearParsingCaches(): void;
  * - const { home } = getInfo(t); // getInfo is imported from './constants'
  * - This will parse constants.ts to find translation calls within getInfo function
  */
-export declare function parseStrings(importName: string, originalName: string, path: NodePath, updates: Updates, errors: string[], file: string, parsingOptions: ParsingConfigOptions): void;
+export declare function parseStrings(importName: string, originalName: string, path: NodePath, updates: Updates, errors: string[], warnings: Set<string>, file: string, parsingOptions: ParsingConfigOptions): void;

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

@@ -1,7 +1,7 @@
 import * as t from '@babel/types';
-import { isStaticExpression } from '../evaluateJsx.js';
+import { isStaticExpression, isValidIcu } from '../evaluateJsx.js';
 import { GT_ATTRIBUTES_WITH_SUGAR, MSG_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } from './constants.js';
-import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, } from '../../../console/index.js';
+import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, warnInvalidIcuSync, } from '../../../console/index.js';
 import generateModule from '@babel/generator';
 import traverseModule from '@babel/traverse';
 // Handle CommonJS/ESM interop
@@ -43,13 +43,21 @@ export function clearParsingCaches() {
  * - Metadata extraction from options object
  * - Error reporting for non-static expressions and template literals with expressions
  */
-function processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent) {
+function processTranslationCall(tPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu) {
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.arguments.length > 0) {
         const arg = tPath.parent.arguments[0];
         if (arg.type === 'StringLiteral' ||
             (t.isTemplateLiteral(arg) && arg.expressions.length === 0)) {
             const source = arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;
+            // Validate is ICU
+            if (!ignoreInvalidIcu) {
+                const { isValid, error } = isValidIcu(source);
+                if (!isValid) {
+                    warnings.add(warnInvalidIcuSync(file, source, error ?? 'Unknown error', `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+                    return;
+                }
+            }
             // get metadata and id from options
             const options = tPath.parent.arguments[1];
             const metadata = {};
@@ -174,11 +182,11 @@ function resolveVariableAliases(scope, variableName, visited = new Set()) {
  * 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, ignoreAdditionalData, ignoreDynamicContent, parsingOptions) {
+function handleFunctionCall(tPath, updates, errors, warnings, file, importMap, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions) {
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.callee === tPath.node) {
         // Direct translation call: t('hello')
-        processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent);
+        processTranslationCall(tPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu);
     }
     else if (tPath.parent.type === 'CallExpression' &&
         t.isExpression(tPath.node) &&
@@ -190,7 +198,7 @@ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAddit
             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, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
+                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
             }
             // Handle arrow functions assigned to variables: const getData = (t) => {...}
             else if (calleeBinding &&
@@ -199,14 +207,14 @@ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAddit
                 (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, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
+                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
             }
             // 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, parsingOptions);
                 if (resolvedPath) {
-                    processFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
+                    processFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, warnings, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
                 }
             }
         }
@@ -217,12 +225,12 @@ function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAddit
  * 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, ignoreAdditionalData, ignoreDynamicContent, parsingOptions) {
+function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, warnings, filePath, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions) {
     if (functionNode.params.length > argIndex) {
         const param = functionNode.params[argIndex];
         const paramName = extractParameterName(param);
         if (paramName) {
-            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
+            findFunctionParameterUsage(functionPath, paramName, updates, errors, warnings, filePath, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
         }
     }
 }
@@ -234,7 +242,7 @@ function processFunctionIfMatches(_functionName, argIndex, functionNode, functio
  * 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, ignoreAdditionalData, ignoreDynamicContent, parsingOptions) {
+function findFunctionParameterUsage(functionPath, parameterName, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions) {
     // Look for the function body and find all usages of the parameter
     if (functionPath.isFunction()) {
         const functionScope = functionPath.scope;
@@ -249,7 +257,7 @@ function findFunctionParameterUsage(functionPath, parameterName, updates, errors
             const binding = functionScope.bindings[name];
             if (binding) {
                 binding.referencePaths.forEach((refPath) => {
-                    handleFunctionCall(refPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
+                    handleFunctionCall(refPath, updates, errors, warnings, file, importMap, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
                 });
             }
         });
@@ -371,7 +379,7 @@ function resolveImportPath(currentFile, importPath, parsingOptions) {
  *
  * If the function is not found in the file, follows re-exports (export * from './other')
  */
-function processFunctionInFile(filePath, functionName, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent, parsingOptions, visited = new Set()) {
+function processFunctionInFile(filePath, functionName, argIndex, updates, errors, warnings, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions, visited = new Set()) {
     // Check cache first to avoid redundant parsing
     const cacheKey = `${filePath}::${functionName}::${argIndex}`;
     if (processFunctionCache.has(cacheKey)) {
@@ -395,7 +403,7 @@ function processFunctionInFile(filePath, functionName, argIndex, updates, errors
             FunctionDeclaration(path) {
                 if (path.node.id?.name === functionName) {
                     found = true;
-                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
+                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, warnings, filePath, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
                 }
             },
             // Handle variable declarations: const getInfo = (t) => { ... }
@@ -407,7 +415,7 @@ function processFunctionInFile(filePath, functionName, argIndex, updates, errors
                         t.isFunctionExpression(path.node.init))) {
                     found = true;
                     const initPath = path.get('init');
-                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
+                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, warnings, filePath, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
                 }
             },
             // Collect re-exports: export * from './other'
@@ -440,7 +448,7 @@ function processFunctionInFile(filePath, functionName, argIndex, updates, errors
             for (const reExportPath of reExports) {
                 const resolvedPath = resolveImportPath(filePath, reExportPath, parsingOptions);
                 if (resolvedPath) {
-                    processFunctionInFile(resolvedPath, functionName, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent, parsingOptions, visited);
+                    processFunctionInFile(resolvedPath, functionName, argIndex, updates, errors, warnings, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions, visited);
                 }
             }
         }
@@ -466,7 +474,7 @@ function processFunctionInFile(filePath, functionName, argIndex, updates, errors
  * - const { home } = getInfo(t); // getInfo is imported from './constants'
  * - This will parse constants.ts to find translation calls within getInfo function
  */
-export function parseStrings(importName, originalName, path, updates, errors, file, parsingOptions) {
+export function parseStrings(importName, originalName, path, updates, errors, warnings, file, parsingOptions) {
     // First, collect all imports in this file to track cross-file function calls
     const importMap = buildImportMap(path.scope.getProgramParent().path);
     const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
@@ -475,10 +483,11 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
         if (originalName === MSG_TRANSLATION_HOOK) {
             const ignoreAdditionalData = false;
             const ignoreDynamicContent = false;
+            const ignoreInvalidIcu = false;
             // Check if this is a direct call to msg('string')
             if (refPath.parent.type === 'CallExpression' &&
                 refPath.parent.callee === refPath.node) {
-                processTranslationCall(refPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent);
+                processTranslationCall(refPath, updates, errors, warnings, file, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu);
             }
             continue;
         }
@@ -505,6 +514,7 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
                 originalName === INLINE_MESSAGE_HOOK_ASYNC;
             const ignoreAdditionalData = isMessageHook;
             const ignoreDynamicContent = isMessageHook;
+            const ignoreInvalidIcu = isMessageHook;
             const effectiveParent = parentPath?.node.type === 'AwaitExpression'
                 ? parentPath.parentPath
                 : parentPath;
@@ -521,7 +531,7 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
                 allTranslationNames.forEach((name) => {
                     const tReferencePaths = variableScope.bindings[name]?.referencePaths || [];
                     for (const tPath of tReferencePaths) {
-                        handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent, parsingOptions);
+                        handleFunctionCall(tPath, updates, errors, warnings, file, importMap, ignoreAdditionalData, ignoreDynamicContent, ignoreInvalidIcu, parsingOptions);
                     }
                 });
             }

package/dist/react/parse/createDictionaryUpdates.d.ts

@@ -1,3 +1,3 @@
 import { BuildOptions } from 'esbuild';
 import { Updates } from '../../types/index.js';
-export declare function createDictionaryUpdates(dictionaryPath: string, esbuildConfig?: BuildOptions): Promise<Updates>;
+export declare function createDictionaryUpdates(dictionaryPath: string, warnings: string[], esbuildConfig?: BuildOptions): Promise<Updates>;

package/dist/react/parse/createDictionaryUpdates.js

@@ -8,7 +8,9 @@ import { hashSource } from 'generaltranslation/id';
 import getEntryAndMetadata from '../utils/getEntryAndMetadata.js';
 import { logError } from '../../console/logging.js';
 import { randomUUID } from 'node:crypto';
-export async function createDictionaryUpdates(dictionaryPath, esbuildConfig) {
+import { isValidIcu } from '../jsx/evaluateJsx.js';
+import { warnInvalidIcuSync } from '../../console/index.js';
+export async function createDictionaryUpdates(dictionaryPath, warnings, esbuildConfig) {
     let dictionary;
     // ---- HANDLE JSON STRING DICTIONARY ----- //
     if (dictionaryPath.endsWith('.json')) {
@@ -45,6 +47,12 @@ export async function createDictionaryUpdates(dictionaryPath, esbuildConfig) {
     for (const id of Object.keys(dictionary)) {
         const { entry, metadata: props, // context, etc.
          } = getEntryAndMetadata(dictionary[id]);
+        // Validate ICU
+        const { isValid, error } = isValidIcu(entry);
+        if (!isValid) {
+            warnings.push(warnInvalidIcuSync(dictionaryPath, entry, error ?? 'Unknown error'));
+            continue;
+        }
         // Map $context to context
         const context = props?.$context;
         const metadata = {

package/dist/react/parse/createInlineUpdates.js

@@ -91,7 +91,7 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
         });
         // Process translation functions asynchronously
         for (const { localName: name, originalName, path } of translationPaths) {
-            parseStrings(name, originalName, path, updates, errors, file, parsingOptions);
+            parseStrings(name, originalName, path, updates, errors, warnings, file, parsingOptions);
         }
         // Parse <T> components
         traverse(ast, {

package/dist/translation/parse.js

@@ -25,7 +25,7 @@ export async function createUpdates(options, src, sourceDictionary, pkg, validat
         if (sourceDictionary.endsWith('.json')) {
             updates = [
                 ...updates,
-                ...(await createDictionaryUpdates(sourceDictionary)),
+                ...(await createDictionaryUpdates(sourceDictionary, warnings)),
             ];
         }
         else {
@@ -43,7 +43,7 @@ export async function createUpdates(options, src, sourceDictionary, pkg, validat
             }
             updates = [
                 ...updates,
-                ...(await createDictionaryUpdates(sourceDictionary, esbuildConfig)),
+                ...(await createDictionaryUpdates(sourceDictionary, warnings, esbuildConfig)),
             ];
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.4.10",
+  "version": "2.4.12",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -68,6 +68,7 @@
     "@babel/plugin-transform-react-jsx": "^7.25.9",
     "@babel/traverse": "^7.25.7",
     "@clack/prompts": "^1.0.0-alpha.1",
+    "@formatjs/icu-messageformat-parser": "^2.11.4",
     "chalk": "^5.4.1",
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",