gtx-cli 2.6.26 → 2.6.27

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 2.6.27
+
+### Patch Changes
+
+- [#1051](https://github.com/generaltranslation/gt/pull/1051) [`d36d4b8`](https://github.com/generaltranslation/gt/commit/d36d4b8459626c552c143fbdfa6d01f647a66533) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: string list registration
+
 ## 2.6.26
 
 ### Patch Changes

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.6.26";
+export declare const PACKAGE_VERSION = "2.6.27";

package/dist/generated/version.js

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

package/dist/react/jsx/evaluateJsx.js

@@ -1,8 +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;
 const MEANINGFUL_REGEX = /[\p{L}\p{N}]/u;
 /**
  * Checks if a node is meaningful. Does not recurse into children.

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

@@ -1,6 +1,11 @@
+/**
+ * Type logic implementation
+ */
+type MapAttributeName<T extends string> = T extends '$id' ? 'id' : T extends '$context' ? 'context' : T extends '$maxChars' ? 'maxChars' : T;
 /**
  * Map the attribute name to the corresponding attribute name in the metadata
  * @param attrName - The attribute name to map
  * @returns The mapped attribute name
  */
-export declare function mapAttributeName(attrName: string): string;
+export declare function mapAttributeName<T extends string>(attrName: T): MapAttributeName<T>;
+export {};

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

@@ -1,14 +1,12 @@
-/**
- * Map the attribute name to the corresponding attribute name in the metadata
- * @param attrName - The attribute name to map
- * @returns The mapped attribute name
- */
 export function mapAttributeName(attrName) {
-    if (attrName === '$id')
-        return 'id';
-    if (attrName === '$context')
-        return 'context';
-    if (attrName === '$maxChars')
-        return 'maxChars';
-    return attrName;
+    switch (attrName) {
+        case '$id':
+            return 'id';
+        case '$context':
+            return 'context';
+        case '$maxChars':
+            return 'maxChars';
+        default:
+            return attrName;
+    }
 }

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

@@ -1,28 +1,9 @@
 import { NodePath, Scope } from '@babel/traverse';
-import { Updates } from '../../../types/index.js';
-import type { ParsingConfigOptions } from '../../../types/parsing.js';
+import type { ParsingConfig, ParsingOutput } from './stringParsing/types.js';
 /**
  * Clears all caches. Useful for testing or when file system changes.
  */
 export declare function clearParsingCaches(): void;
-/**
- * Immutable configuration options for string parsing.
- */
-type ParsingConfig = {
-    parsingOptions: ParsingConfigOptions;
-    file: string;
-    ignoreAdditionalData: boolean;
-    ignoreDynamicContent: boolean;
-    ignoreInvalidIcu: boolean;
-};
-/**
- * Collectors for updates, errors, and warnings.
- */
-type ParsingOutput = {
-    updates: Updates;
-    errors: string[];
-    warnings: Set<string>;
-};
 /**
  * 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;
@@ -47,4 +28,3 @@ export declare function resolveVariableAliases(scope: Scope, variableName: strin
  * - This will parse constants.ts to find translation calls within getInfo function
  */
 export declare function parseStrings(importName: string, originalName: string, path: NodePath, config: ParsingConfig, output: ParsingOutput): void;
-export {};

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

@@ -1,23 +1,14 @@
 import * as t from '@babel/types';
-import { isStaticExpression, isValidIcu } from '../evaluateJsx.js';
-import { GT_ATTRIBUTES_WITH_SUGAR, MSG_REGISTRATION_FUNCTION, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } from './constants.js';
-import { mapAttributeName } from './mapAttributeName.js';
-import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, warnInvalidIcuSync, warnInvalidMaxCharsSync, } from '../../../console/index.js';
-import generateModule from '@babel/generator';
+import { MSG_REGISTRATION_FUNCTION, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } from './constants.js';
+import { warnAsyncUseGT, warnSyncGetGT } from '../../../console/index.js';
 import traverseModule from '@babel/traverse';
 // Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
 const traverse = traverseModule.default || traverseModule;
 import fs from 'node:fs';
-import pathModule from 'node:path';
 import { parse } from '@babel/parser';
 import { resolveImportPath } from './resolveImportPath.js';
 import { buildImportMap } from './buildImportMap.js';
-import { handleStaticExpression } from './parseDeclareStatic.js';
-import { nodeToStrings } from './parseString.js';
-import { isNumberLiteral } from './isNumberLiteral.js';
-import { indexVars } from 'generaltranslation/internal';
-import { randomUUID } from 'node:crypto';
+import { processTranslationCall } from './stringParsing/processTranslationCall/index.js';
 /**
  * Cache for resolved import paths to avoid redundant I/O operations.
  * Key: `${currentFile}::${importPath}`
@@ -37,155 +28,6 @@ export function clearParsingCaches() {
     resolveImportPathCache.clear();
     processFunctionCache.clear();
 }
-/**
- * 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.
- *
- * Handles:
- * - String literals: t('hello')
- * - Template literals without expressions: t(`hello`)
- * - Metadata extraction from options object
- * - Error reporting for non-static expressions and template literals with expressions
- */
-function processTranslationCall(tPath, config, output) {
-    if (tPath.parent.type === 'CallExpression' &&
-        tPath.parent.arguments.length > 0) {
-        const arg = tPath.parent.arguments[0];
-        // if (t.isExpression(arg)) {
-        if (!config.ignoreDynamicContent &&
-            t.isExpression(arg) &&
-            !isStaticExpression(arg).isStatic) {
-            const result = handleStaticExpression(arg, tPath, config.file, config.parsingOptions, output.errors);
-            if (result) {
-                const strings = nodeToStrings(result).map(indexVars);
-                if (!config.ignoreInvalidIcu) {
-                    for (const string of strings) {
-                        const { isValid, error } = isValidIcu(string);
-                        if (!isValid) {
-                            output.warnings.add(warnInvalidIcuSync(config.file, string, 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 = {};
-                if (options && options.type === 'ObjectExpression') {
-                    options.properties.forEach((prop) => {
-                        if (prop.type === 'ObjectProperty' &&
-                            prop.key.type === 'Identifier') {
-                            const attribute = prop.key.name;
-                            if (GT_ATTRIBUTES_WITH_SUGAR.includes(attribute) &&
-                                t.isExpression(prop.value)) {
-                                const result = isStaticExpression(prop.value);
-                                if (!result.isStatic) {
-                                    output.errors.push(warnNonStaticExpressionSync(config.file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                                }
-                                if (result.isStatic &&
-                                    result.value &&
-                                    !config.ignoreAdditionalData) {
-                                    // Map $id and $context to id and context
-                                    metadata[mapAttributeName(attribute)] = result.value;
-                                }
-                            }
-                        }
-                    });
-                }
-                const temporaryStaticId = `static-temp-id-${randomUUID()}`;
-                for (const string of strings) {
-                    output.updates.push({
-                        dataFormat: 'ICU',
-                        source: string,
-                        metadata: { ...metadata, staticId: temporaryStaticId },
-                    });
-                }
-                return;
-            }
-            // Nothing returned, push error
-            output.errors.push(warnNonStringSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-            // ignore dynamic content flag is triggered, check strings are valid ICU
-        }
-        else 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 (!config.ignoreInvalidIcu) {
-                const { isValid, error } = isValidIcu(source);
-                if (!isValid) {
-                    output.warnings.add(warnInvalidIcuSync(config.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 = {};
-            if (options && options.type === 'ObjectExpression') {
-                options.properties.forEach((prop) => {
-                    if (prop.type === 'ObjectProperty' &&
-                        prop.key.type === 'Identifier') {
-                        const attribute = prop.key.name;
-                        if (GT_ATTRIBUTES_WITH_SUGAR.includes(attribute) &&
-                            t.isExpression(prop.value)) {
-                            const result = isStaticExpression(prop.value);
-                            if (!result.isStatic) {
-                                output.errors.push(warnNonStaticExpressionSync(config.file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                            }
-                            if (result.isStatic &&
-                                result.value &&
-                                !config.ignoreAdditionalData) {
-                                const mappedKey = mapAttributeName(attribute);
-                                if (attribute === '$maxChars') {
-                                    if ((typeof result.value === 'string' &&
-                                        (isNaN(Number(result.value)) ||
-                                            !isNumberLiteral(prop.value))) ||
-                                        !Number.isInteger(Number(result.value))) {
-                                        output.errors.push(warnInvalidMaxCharsSync(config.file, generate(prop).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                                    }
-                                    else if (typeof result.value === 'string') {
-                                        // Add the maxChars value to the metadata
-                                        metadata[mappedKey] = Math.abs(Number(result.value));
-                                    }
-                                }
-                                else {
-                                    // Add the $context or $id or other attributes value to the metadata
-                                    metadata[mappedKey] = result.value;
-                                }
-                            }
-                        }
-                    }
-                });
-            }
-            const relativeFilepath = pathModule.relative(process.cwd(), config.file);
-            if (relativeFilepath) {
-                if (!metadata.filePaths) {
-                    metadata.filePaths = [relativeFilepath];
-                }
-                else if (Array.isArray(metadata.filePaths)) {
-                    if (!metadata.filePaths.includes(relativeFilepath)) {
-                        metadata.filePaths.push(relativeFilepath);
-                    }
-                }
-            }
-            output.updates.push({
-                dataFormat: 'ICU',
-                source,
-                metadata,
-            });
-        }
-        else if (t.isTemplateLiteral(arg)) {
-            // warn if template literal
-            if (!config.ignoreDynamicContent) {
-                output.errors.push(warnTemplateLiteralSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-            }
-        }
-        else {
-            if (!config.ignoreDynamicContent) {
-                output.errors.push(warnNonStringSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-            }
-        }
-        // }
-    }
-}
 /**
  * Extracts the parameter name from a function parameter node, handling TypeScript annotations and default values.
  */
@@ -437,9 +279,10 @@ export function parseStrings(importName, originalName, path, config, output) {
             const msgConfig = {
                 parsingOptions: config.parsingOptions,
                 file: config.file,
-                ignoreAdditionalData: false,
+                ignoreInlineMetadata: false,
                 ignoreDynamicContent: false,
                 ignoreInvalidIcu: false,
+                ignoreInlineListContent: false,
             };
             // Check if this is a direct call to msg('string')
             if (refPath.parent.type === 'CallExpression' &&
@@ -469,12 +312,16 @@ export function parseStrings(importName, originalName, path, config, output) {
             }
             const isMessageHook = originalName === INLINE_MESSAGE_HOOK ||
                 originalName === INLINE_MESSAGE_HOOK_ASYNC;
+            const isInlineGT = originalName === INLINE_TRANSLATION_HOOK ||
+                originalName === INLINE_TRANSLATION_HOOK_ASYNC;
             const hookConfig = {
                 parsingOptions: config.parsingOptions,
                 file: config.file,
-                ignoreAdditionalData: isMessageHook,
+                ignoreInlineMetadata: isMessageHook,
                 ignoreDynamicContent: isMessageHook,
                 ignoreInvalidIcu: isMessageHook,
+                // TODO: when we add support for array content in gt function, this should just always be false
+                ignoreInlineListContent: isInlineGT,
             };
             const effectiveParent = parentPath?.node.type === 'AwaitExpression'
                 ? parentPath.parentPath

package/dist/react/jsx/utils/stringParsing/processTranslationCall/extractStringEntryMetadata.d.ts

@@ -0,0 +1,29 @@
+import * as t from '@babel/types';
+import { ParsingConfig } from '../types.js';
+import { ParsingOutput } from '../types.js';
+/**
+ * Metadata record type
+ */
+export type InlineMetadata = {
+    maxChars?: number;
+    context?: string;
+    id?: string;
+    hash?: string;
+    filePaths?: string[];
+};
+/**
+ * Extracts inline metadata from a string entry
+ * @param metadata - The metadata record to inject the data into
+ * @param entry - The string entry to extract the metadata from
+ * @param output - The output to use
+ * @param config - The configuration to use
+ * @returns The inline metadata
+ *
+ * @note - this function does not automatically append the index to the id, this must be done manually in the caller.
+ *
+ */
+export declare function extractStringEntryMetadata({ options, output, config, }: {
+    options?: t.CallExpression['arguments'][number];
+    output: ParsingOutput;
+    config: ParsingConfig;
+}): InlineMetadata;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/extractStringEntryMetadata.js

@@ -0,0 +1,86 @@
+import * as t from '@babel/types';
+import { isStaticExpression } from '../../../evaluateJsx.js';
+import { warnInvalidMaxCharsSync } from '../../../../../console/index.js';
+import { warnNonStaticExpressionSync } from '../../../../../console/index.js';
+import { GT_ATTRIBUTES_WITH_SUGAR } from '../../constants.js';
+import generateModule from '@babel/generator';
+import { mapAttributeName } from '../../mapAttributeName.js';
+import pathModule from 'node:path';
+import { isNumberLiteral } from '../../isNumberLiteral.js';
+// Handle CommonJS/ESM interop
+const generate = generateModule.default || generateModule;
+/**
+ * Extracts inline metadata from a string entry
+ * @param metadata - The metadata record to inject the data into
+ * @param entry - The string entry to extract the metadata from
+ * @param output - The output to use
+ * @param config - The configuration to use
+ * @returns The inline metadata
+ *
+ * @note - this function does not automatically append the index to the id, this must be done manually in the caller.
+ *
+ */
+export function extractStringEntryMetadata({ options, output, config, }) {
+    // extract filepath for entry
+    const relativeFilepath = pathModule.relative(process.cwd(), config.file);
+    // extract inline metadata
+    const inlineMetadata = extractInlineMetadata({
+        options,
+        output,
+        config,
+    });
+    return {
+        ...inlineMetadata,
+        filePaths: relativeFilepath ? [relativeFilepath] : undefined,
+    };
+}
+// ----- Helper Functions ----- //
+/**
+ * Extracts inline metadata specified e.g. gt('Hello', { $context: 'greeting' })
+ * @param options - The options to extract the metadata from
+ * @param output - The output to use
+ * @param config - The configuration to use
+ * @param index - The index of the string entry
+ * @returns The inline metadata
+ */
+function extractInlineMetadata({ options, output, config, }) {
+    const metadata = {};
+    if (options && options.type === 'ObjectExpression') {
+        options.properties.forEach((prop) => {
+            if (prop.type === 'ObjectProperty' && prop.key.type === 'Identifier') {
+                const attribute = prop.key.name;
+                if (GT_ATTRIBUTES_WITH_SUGAR.includes(attribute) &&
+                    t.isExpression(prop.value)) {
+                    const result = isStaticExpression(prop.value);
+                    if (!result.isStatic) {
+                        output.errors.push(warnNonStaticExpressionSync(config.file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+                    }
+                    if (result.isStatic &&
+                        result.value != null &&
+                        !config.ignoreInlineMetadata) {
+                        const mappedKey = mapAttributeName(attribute);
+                        if (mappedKey === 'maxChars') {
+                            // Handle maxChars attribute
+                            if ((typeof result.value === 'string' &&
+                                (isNaN(Number(result.value)) ||
+                                    !isNumberLiteral(prop.value))) ||
+                                !Number.isInteger(Number(result.value))) {
+                                output.errors.push(warnInvalidMaxCharsSync(config.file, generate(prop).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+                            }
+                            else if (typeof result.value === 'string') {
+                                // Add the maxChars value to the metadata
+                                metadata[mappedKey] = Math.abs(Number(result.value));
+                            }
+                        }
+                        else {
+                            // Add the $context or $id or other attributes value to the metadata
+                            // TODO: why are we including everything? arent we only interested in relevant inline metadata?
+                            metadata[mappedKey] = result.value;
+                        }
+                    }
+                }
+            }
+        });
+    }
+    return metadata;
+}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleInvalidTranslationCall.d.ts

@@ -0,0 +1,14 @@
+import * as t from '@babel/types';
+import { ParsingConfig, ParsingOutput } from '../types.js';
+/**
+ * For the processTranslationCall function, this function handles the case where a other translation call is used.
+ * Error is pushed if the other translation call is used.
+ * @param arg - The argument to parse
+ * @param config - The configuration to use
+ * @param output - The output to use
+ */
+export declare function handleInvalidTranslationCall({ arg, config, output, }: {
+    arg: t.ArgumentPlaceholder | t.SpreadElement | t.Expression;
+    config: ParsingConfig;
+    output: ParsingOutput;
+}): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleInvalidTranslationCall.js

@@ -0,0 +1,24 @@
+import * as t from '@babel/types';
+import { warnNonStringSync, warnTemplateLiteralSync, } from '../../../../../console/index.js';
+import generateModule from '@babel/generator';
+// Handle CommonJS/ESM interop
+const generate = generateModule.default || generateModule;
+/**
+ * For the processTranslationCall function, this function handles the case where a other translation call is used.
+ * Error is pushed if the other translation call is used.
+ * @param arg - The argument to parse
+ * @param config - The configuration to use
+ * @param output - The output to use
+ */
+export function handleInvalidTranslationCall({ arg, config, output, }) {
+    if (config.ignoreDynamicContent)
+        return;
+    if (t.isTemplateLiteral(arg)) {
+        // Specific error for template literals
+        output.errors.push(warnTemplateLiteralSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+    }
+    else {
+        // Generic error
+        output.errors.push(warnNonStringSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+    }
+}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleLiteralTranslationCall.d.ts

@@ -0,0 +1,19 @@
+import * as t from '@babel/types';
+import { ParsingConfig } from '../types.js';
+import { ParsingOutput } from '../types.js';
+import { InlineMetadata } from './extractStringEntryMetadata.js';
+/**
+ * For the processTranslationCall function, this function handles the case where a string literal or template literal is used.
+ * @param arg - The argument to parse
+ * @param metadata - The metadata to use
+ * @param config - The configuration to use
+ * @param output - The output to use
+ * @param index - The index of the argument
+ */
+export declare function handleLiteralTranslationCall({ arg, metadata, config, output, index, }: {
+    arg: t.StringLiteral | t.TemplateLiteral;
+    metadata: InlineMetadata;
+    config: ParsingConfig;
+    output: ParsingOutput;
+    index?: number;
+}): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleLiteralTranslationCall.js

@@ -0,0 +1,31 @@
+import { isValidIcu } from '../../../evaluateJsx.js';
+import { warnInvalidIcuSync } from '../../../../../console/index.js';
+/**
+ * For the processTranslationCall function, this function handles the case where a string literal or template literal is used.
+ * @param arg - The argument to parse
+ * @param metadata - The metadata to use
+ * @param config - The configuration to use
+ * @param output - The output to use
+ * @param index - The index of the argument
+ */
+export function handleLiteralTranslationCall({ arg, metadata, config, output, index, }) {
+    // ignore dynamic content flag is triggered, check strings are valid ICU
+    const source = arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;
+    // Validate is ICU
+    if (!config.ignoreInvalidIcu) {
+        const { isValid, error } = isValidIcu(source);
+        if (!isValid) {
+            output.warnings.add(warnInvalidIcuSync(config.file, source, error ?? 'Unknown error', `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+            return;
+        }
+    }
+    output.updates.push({
+        dataFormat: 'ICU',
+        source,
+        metadata: {
+            ...metadata,
+            // Add the index if an id and index is provided (for handling when registering an array of strings)
+            ...(metadata.id && index != null && { id: `${metadata.id}.${index}` }),
+        },
+    });
+}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleStaticTranslationCall.d.ts

@@ -0,0 +1,22 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { ParsingConfig } from '../types.js';
+import { ParsingOutput } from '../types.js';
+import { InlineMetadata } from './extractStringEntryMetadata.js';
+/**
+ * For the processTranslationCall function, this function handles the case where a string with declareStatic is used.
+ * @param arg - The argument to parse
+ * @param metadata - The metadata to use
+ * @param tPath - The path to the argument
+ * @param config - The configuration to use
+ * @param output - The output to use
+ * @param index - Current index in array of strings being extracted
+ */
+export declare function handleStaticTranslationCall({ arg, metadata, tPath, config, output, index, }: {
+    arg: t.Expression;
+    metadata: InlineMetadata;
+    tPath: NodePath;
+    config: ParsingConfig;
+    output: ParsingOutput;
+    index?: number;
+}): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleStaticTranslationCall.js

@@ -0,0 +1,51 @@
+import { handleStaticExpression } from '../../parseDeclareStatic.js';
+import { nodeToStrings } from '../../parseString.js';
+import { indexVars } from 'generaltranslation/internal';
+import { isValidIcu } from '../../../evaluateJsx.js';
+import { warnInvalidIcuSync, warnNonStringSync, } from '../../../../../console/index.js';
+import generateModule from '@babel/generator';
+import { randomUUID } from 'node:crypto';
+// Handle CommonJS/ESM interop
+const generate = generateModule.default || generateModule;
+/**
+ * For the processTranslationCall function, this function handles the case where a string with declareStatic is used.
+ * @param arg - The argument to parse
+ * @param metadata - The metadata to use
+ * @param tPath - The path to the argument
+ * @param config - The configuration to use
+ * @param output - The output to use
+ * @param index - Current index in array of strings being extracted
+ */
+export function handleStaticTranslationCall({ arg, metadata, tPath, config, output, index, }) {
+    // parse static expression
+    const result = handleStaticExpression(arg, tPath, config.file, config.parsingOptions, output.errors);
+    // Nothing returned, push error
+    if (!result) {
+        output.errors.push(warnNonStringSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+        return;
+    }
+    // validate ICU
+    const strings = nodeToStrings(result).map(indexVars);
+    if (!config.ignoreInvalidIcu) {
+        for (const string of strings) {
+            const { isValid, error } = isValidIcu(string);
+            if (!isValid) {
+                output.warnings.add(warnInvalidIcuSync(config.file, string, error ?? 'Unknown error', `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+                return;
+            }
+        }
+    }
+    const temporaryStaticId = `static-temp-id-${randomUUID()}`;
+    for (const string of strings) {
+        output.updates.push({
+            dataFormat: 'ICU',
+            source: string,
+            metadata: {
+                ...metadata,
+                // Add the index if an id and index is provided (for handling when registering an array of strings)
+                ...(metadata.id && index != null && { id: `${metadata.id}.${index}` }),
+                staticId: temporaryStaticId,
+            },
+        });
+    }
+}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/index.d.ts

@@ -0,0 +1,18 @@
+import { NodePath } from '@babel/traverse';
+import { ParsingConfig } from '../types.js';
+import { ParsingOutput } from '../types.js';
+/**
+ * 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.
+ *
+ * Handles:
+ * - String literals: t('hello')
+ * - Template literals without expressions: t(`hello`)
+ * - Metadata extraction from options object
+ * - Error reporting for non-static expressions and template literals with expressions
+ *
+ * @param tPath - The path to the translation call
+ * @param config - The configuration to use
+ * @param output - The output to use
+ */
+export declare function processTranslationCall(tPath: NodePath, config: ParsingConfig, output: ParsingOutput): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/index.js

@@ -0,0 +1,39 @@
+import { routeTranslationCall } from './routeTranslationCall.js';
+import { extractStringEntryMetadata } from './extractStringEntryMetadata.js';
+/**
+ * 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.
+ *
+ * Handles:
+ * - String literals: t('hello')
+ * - Template literals without expressions: t(`hello`)
+ * - Metadata extraction from options object
+ * - Error reporting for non-static expressions and template literals with expressions
+ *
+ * @param tPath - The path to the translation call
+ * @param config - The configuration to use
+ * @param output - The output to use
+ */
+export function processTranslationCall(tPath, config, output) {
+    if (tPath.parent.type !== 'CallExpression' ||
+        tPath.parent.arguments.length === 0) {
+        return;
+    }
+    // Get arg and options
+    const arg = tPath.parent.arguments[0];
+    const options = tPath.parent.arguments.at(1);
+    // get metadata and id from options
+    const metadata = extractStringEntryMetadata({
+        options,
+        output,
+        config,
+    });
+    // Route tx call to appropriate handler
+    routeTranslationCall({
+        tPath,
+        config,
+        output,
+        arg,
+        metadata,
+    });
+}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/routeTranslationCall.d.ts

@@ -0,0 +1,24 @@
+import * as t from '@babel/types';
+import { ParsingConfig } from '../types.js';
+import { ParsingOutput } from '../types.js';
+import { NodePath } from '@babel/traverse';
+import { InlineMetadata } from './extractStringEntryMetadata.js';
+/**
+ * Helper function for processTranslationCall
+ * Given arg and options, maps to appropriate translation call handler
+ * @param tPath - The path to the translation call
+ * @param config - The configuration to use
+ * @param output - The output to use
+ * @param arg - The argument to parse
+ * @param metadata - The metadata to use
+ * @param index - The index of the argument
+ * @returns void
+ */
+export declare function routeTranslationCall({ tPath, config, output, arg, metadata, index, }: {
+    tPath: NodePath;
+    config: ParsingConfig;
+    output: ParsingOutput;
+    arg: t.CallExpression['arguments'][number];
+    metadata: InlineMetadata;
+    index?: number;
+}): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/routeTranslationCall.js

@@ -0,0 +1,68 @@
+import { isStaticExpression } from '../../../evaluateJsx.js';
+import { handleStaticTranslationCall } from './handleStaticTranslationCall.js';
+import { handleLiteralTranslationCall } from './handleLiteralTranslationCall.js';
+import { handleInvalidTranslationCall } from './handleInvalidTranslationCall.js';
+import * as t from '@babel/types';
+/**
+ * Helper function for processTranslationCall
+ * Given arg and options, maps to appropriate translation call handler
+ * @param tPath - The path to the translation call
+ * @param config - The configuration to use
+ * @param output - The output to use
+ * @param arg - The argument to parse
+ * @param metadata - The metadata to use
+ * @param index - The index of the argument
+ * @returns void
+ */
+export function routeTranslationCall({ tPath, config, output, arg, metadata, index, }) {
+    if (t.isArrayExpression(arg) &&
+        index == null &&
+        !config.ignoreInlineListContent) {
+        // handle array translation call
+        for (let i = 0; i < arg.elements.length; i++) {
+            const element = arg.elements[i];
+            if (element == null)
+                continue;
+            routeTranslationCall({
+                tPath,
+                config,
+                output,
+                arg: element,
+                index: i,
+                metadata,
+            });
+        }
+    }
+    else if (!config.ignoreDynamicContent &&
+        t.isExpression(arg) &&
+        !isStaticExpression(arg).isStatic) {
+        // handle static translation call
+        handleStaticTranslationCall({
+            arg,
+            metadata,
+            tPath,
+            config,
+            output,
+            index,
+        });
+    }
+    else if (arg.type === 'StringLiteral' ||
+        (t.isTemplateLiteral(arg) && arg.expressions.length === 0)) {
+        // Handle string and template literals
+        handleLiteralTranslationCall({
+            arg,
+            metadata,
+            config,
+            output,
+            index,
+        });
+    }
+    else {
+        // error on invalid translation call
+        handleInvalidTranslationCall({
+            arg,
+            config,
+            output,
+        });
+    }
+}

package/dist/react/jsx/utils/stringParsing/types.d.ts

@@ -0,0 +1,41 @@
+import { ParsingConfigOptions } from '../../../../types/parsing.js';
+import { Updates } from '../../../../types/index.js';
+/**
+ * Immutable configuration options for string parsing.
+ */
+export type ParsingConfig = {
+    parsingOptions: ParsingConfigOptions;
+    file: string;
+    /**
+     * If true, ignores fields like $context, $id, etc. when extracting metadata from a string entry
+     */
+    ignoreInlineMetadata: boolean;
+    /**
+     * If true, dynamic content will not be treated as errors
+     */
+    ignoreDynamicContent: boolean;
+    /**
+     * If true, invalid ICU strings will not be treated as errors
+     */
+    ignoreInvalidIcu: boolean;
+    /**
+     * If true, will ignore registration of list content
+     * eg msg(['hello', 'world', 'foo', 'bar']) will not be registered
+     */
+    ignoreInlineListContent: boolean;
+};
+/**
+ * Mutable state for tracking parsing progress.
+ */
+export type ParsingState = {
+    visited: Set<string>;
+    importMap: Map<string, string>;
+};
+/**
+ * Collectors for updates, errors, and warnings.
+ */
+export type ParsingOutput = {
+    updates: Updates;
+    errors: string[];
+    warnings: Set<string>;
+};

package/dist/react/jsx/utils/stringParsing/types.js

@@ -0,0 +1 @@
+export {};

package/dist/react/parse/createInlineUpdates.js

@@ -35,9 +35,10 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
             parseStrings(name, originalName, path, {
                 parsingOptions,
                 file,
-                ignoreAdditionalData: false,
+                ignoreInlineMetadata: false,
                 ignoreDynamicContent: false,
                 ignoreInvalidIcu: false,
+                ignoreInlineListContent: false,
             }, { updates, errors, warnings });
         }
         // Parse <T> components

package/package.json

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