gt 2.14.3 → 2.14.4

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # gtx-cli
 
+## 2.14.4
+
+### Patch Changes
+
+- [#1158](https://github.com/generaltranslation/gt/pull/1158) [`5b85ccd`](https://github.com/generaltranslation/gt/commit/5b85ccd80b93b91eae9c873b258a13b6a57443c8) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - add auto injection for jsx translation
+
+- Updated dependencies [[`5b85ccd`](https://github.com/generaltranslation/gt/commit/5b85ccd80b93b91eae9c873b258a13b6a57443c8)]:
+  - generaltranslation@8.2.2
+  - @generaltranslation/python-extractor@0.2.6
+
 ## 2.14.3
 
 ### Patch Changes

package/dist/config/defaults.js

@@ -4,8 +4,9 @@
  * @property {boolean} includeSourceCodeContext - Include surrounding source code lines as context for translations.
  */
 export const GT_PARSING_FLAGS_DEFAULT = {
-    autoDerive: true,
+    autoDerive: false,
     includeSourceCodeContext: false,
+    enableAutoJsxInjection: false,
 };
 /**
  * Default parsing flags for all files

package/dist/console/index.d.ts

@@ -5,6 +5,7 @@ export declare const warnMissingReturnSync: (file: string, functionName: string,
 export declare const warnHasUnwrappedExpressionSync: (file: string, unwrappedExpressions: string[], id?: string, location?: string) => string;
 export declare const warnFailedToConstructJsxTreeSync: (file: string, code: string, location?: string) => string;
 export declare const warnNestedTComponent: (file: string, location?: string) => string;
+export declare const warnNestedInternalTComponent: (file: string, location?: string) => string;
 export declare const warnNonStaticExpressionSync: (file: string, attrName: string, value: string, location?: string) => string;
 export declare const warnInvalidMaxCharsSync: (file: string, value: string, location?: string) => string;
 export declare const warnInvalidFormatSync: (file: string, value: string, location?: string) => string;

package/dist/console/index.js

@@ -14,6 +14,7 @@ export const warnMissingReturnSync = (file, functionName, location) => withLocat
 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 warnFailedToConstructJsxTreeSync = (file, code, location) => withLocation(file, `Failed to construct JsxTree! Call expression is not a valid createElement call: ${colorizeContent(code)}`, location);
 export const warnNestedTComponent = (file, location) => withLocation(file, `Found nested <T> component. <T> components cannot be directly nested.`, location);
+export const warnNestedInternalTComponent = (file, location) => withLocation(file, `DEBUG: Found nested <GtInternalTranslateJsx> component. <GtInternalTranslateJsx> 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 warnInvalidMaxCharsSync = (file, value, location) => withLocation(file, `Found invalid maxChars value: ${colorizeContent(value)}. Change the value to a valid number to ensure this content is translated.`, location);
 export const warnInvalidFormatSync = (file, value, location) => withLocation(file, `Found invalid $format value: ${colorizeContent(value)}. Must be one of: 'ICU', 'STRING', 'I18NEXT'.`, location);

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.14.3";
+export declare const PACKAGE_VERSION = "2.14.4";

package/dist/generated/version.js

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

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

@@ -18,6 +18,9 @@ export declare const TRANSLATION_COMPONENT = "T";
 export declare const STATIC_COMPONENT = "Static";
 export declare const DERIVE_COMPONENT = "Derive";
 export declare const BRANCH_COMPONENT = "Branch";
+export declare const DEFAULT_GT_IMPORT_SOURCE = "gt-react/browser";
+export declare const INTERNAL_TRANSLATION_COMPONENT = "GtInternalTranslateJsx";
+export declare const INTERNAL_VAR_COMPONENT = "GtInternalVar";
 export declare const VAR_COMPONENT = "Var";
 export declare const DATETIME_COMPONENT = "DateTime";
 export declare const RELATIVE_TIME_COMPONENT = "RelativeTime";
@@ -31,4 +34,8 @@ export declare const VARIABLE_COMPONENTS: string[];
 export declare const GT_ATTRIBUTES_WITH_SUGAR: readonly ["$id", "$context", "$maxChars", "$format"];
 export declare const GT_ATTRIBUTES: readonly ["id", "context", "maxChars", "$id", "$context", "$maxChars", "$format"];
 export declare const DATA_ATTR_PREFIX: "data-";
+/** Branch control props — not translatable content. */
+export declare const BRANCH_CONTROL_PROPS: Set<string>;
+/** Plural control props — not translatable content. */
+export declare const PLURAL_CONTROL_PROPS: Set<string>;
 export declare const T_GLOBAL_REGISTRATION_FUNCTION_MARKER = "_gt_internal_t_global_registration_marker";

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

@@ -18,6 +18,9 @@ export const TRANSLATION_COMPONENT = 'T';
 export const STATIC_COMPONENT = 'Static';
 export const DERIVE_COMPONENT = 'Derive';
 export const BRANCH_COMPONENT = 'Branch';
+export const DEFAULT_GT_IMPORT_SOURCE = 'gt-react/browser';
+export const INTERNAL_TRANSLATION_COMPONENT = 'GtInternalTranslateJsx';
+export const INTERNAL_VAR_COMPONENT = 'GtInternalVar';
 // Variable components
 export const VAR_COMPONENT = 'Var';
 export const DATETIME_COMPONENT = 'DateTime';
@@ -45,6 +48,8 @@ export const GT_TRANSLATION_FUNCS = [
     CURRENCY_COMPONENT,
     NUM_COMPONENT,
     BRANCH_COMPONENT,
+    INTERNAL_TRANSLATION_COMPONENT,
+    INTERNAL_VAR_COMPONENT,
     PLURAL_COMPONENT,
 ];
 // GT String translation functions
@@ -66,6 +71,7 @@ export const VARIABLE_COMPONENTS = [
     NUM_COMPONENT,
     STATIC_COMPONENT,
     DERIVE_COMPONENT,
+    INTERNAL_VAR_COMPONENT,
 ];
 export const GT_ATTRIBUTES_WITH_SUGAR = [
     '$id',
@@ -81,5 +87,9 @@ export const GT_ATTRIBUTES = [
 ];
 // Data attribute prefix injected by build tools
 export const DATA_ATTR_PREFIX = 'data-';
+/** Branch control props — not translatable content. */
+export const BRANCH_CONTROL_PROPS = new Set(['branch']);
+/** Plural control props — not translatable content. */
+export const PLURAL_CONTROL_PROPS = new Set(['n', 'locales']);
 // demarcation for global t macro
 export const T_GLOBAL_REGISTRATION_FUNCTION_MARKER = '_gt_internal_t_global_registration_marker';

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

@@ -1,5 +1,5 @@
 import traverseModule from '@babel/traverse';
-import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_REGISTRATION_FUNCTION, T_REGISTRATION_FUNCTION, TRANSLATION_COMPONENT, T_GLOBAL_REGISTRATION_FUNCTION, T_GLOBAL_REGISTRATION_FUNCTION_MARKER, } from '../../jsx/utils/constants.js';
+import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_REGISTRATION_FUNCTION, T_REGISTRATION_FUNCTION, TRANSLATION_COMPONENT, INTERNAL_TRANSLATION_COMPONENT, T_GLOBAL_REGISTRATION_FUNCTION, T_GLOBAL_REGISTRATION_FUNCTION_MARKER, } from '../../jsx/utils/constants.js';
 import { extractImportName } from './parseAst.js';
 import * as t from '@babel/types';
 // Handle CommonJS/ESM interop
@@ -45,7 +45,8 @@ export function getPathsAndAliases(ast, pkgs) {
                             originalName: name.original,
                         });
                     }
-                    else if (name.original === TRANSLATION_COMPONENT) {
+                    else if (name.original === TRANSLATION_COMPONENT ||
+                        name.original === INTERNAL_TRANSLATION_COMPONENT) {
                         translationComponentPaths.push({
                             localName: name.local,
                             path,
@@ -82,7 +83,8 @@ export function getPathsAndAliases(ast, pkgs) {
                                     originalName: name.original,
                                 });
                             }
-                            else if (name.original === TRANSLATION_COMPONENT) {
+                            else if (name.original === TRANSLATION_COMPONENT ||
+                                name.original === INTERNAL_TRANSLATION_COMPONENT) {
                                 translationComponentPaths.push({
                                     localName: name.local,
                                     path: parentPath,

package/dist/react/jsx/utils/jsxParsing/addGTIdentifierToSyntaxTree.d.ts

@@ -6,4 +6,4 @@ import { MultipliedTreeNode } from './types.js';
  * @param startingIndex - The starting index for GT IDs
  * @returns The tree with GT identifiers added
  */
-export default function addGTIdentifierToSyntaxTree(tree: MultipliedTreeNode, startingIndex?: number): JsxChildren;
+export default function addGTIdentifierToSyntaxTree(tree: MultipliedTreeNode, startingIndex?: number, gtVariableNames?: Set<string>): JsxChildren;

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

@@ -1,7 +1,7 @@
 import { HTML_CONTENT_PROPS, } from 'generaltranslation/types';
 import { defaultVariableNames, getVariableName, minifyVariableType, } from '../../../utils/getVariableName.js';
 import { isAcceptedPluralForm } from 'generaltranslation/internal';
-import { DATA_ATTR_PREFIX } from '../constants.js';
+import { DATA_ATTR_PREFIX, BRANCH_COMPONENT, PLURAL_COMPONENT, } from '../constants.js';
 /**
  * Construct the data-_gt prop
  * @param type - The type of the element
@@ -18,7 +18,7 @@ function constructGTProp(type, props, id) {
         return acc;
     }, {});
     // Plural
-    if (type === 'Plural') {
+    if (type === PLURAL_COMPONENT) {
         const pluralBranches = Object.entries(props).reduce((acc, [branchName, branch]) => {
             if (isAcceptedPluralForm(branchName)) {
                 acc[branchName] = addGTIdentifierToSyntaxTree(branch, id);
@@ -32,7 +32,7 @@ function constructGTProp(type, props, id) {
         }
         // Branch
     }
-    else if (type === 'Branch') {
+    else if (type === BRANCH_COMPONENT) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
         const { children, branch, ...allBranches } = props;
         // Filter out data-* attributes injected by build tools
@@ -57,7 +57,7 @@ function constructGTProp(type, props, id) {
  * @param startingIndex - The starting index for GT IDs
  * @returns The tree with GT identifiers added
  */
-export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
+export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0, gtVariableNames) {
     // Edge case: boolean or null, just return the tree
     if (typeof tree === 'boolean' || tree === null) {
         return tree;
@@ -79,8 +79,11 @@ export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
             if (type === 'React.Fragment') {
                 type = '';
             }
-            // Variables
-            if (Object.keys(defaultVariableNames).includes(type)) {
+            // Variables — only treat as GT variable if confirmed as GT import
+            const isGTVariable = gtVariableNames
+                ? gtVariableNames.has(type)
+                : Object.keys(defaultVariableNames).includes(type);
+            if (isGTVariable) {
                 const variableType = minifyVariableType(type);
                 const variableName = getVariableName(props, type, indexObject.index);
                 return {
@@ -91,9 +94,21 @@ export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
             }
             // Construct the data-_gt prop
             const generaltranslation = constructGTProp(type, (props || {}), indexObject.index);
-            // Save current index and recurse
+            // Save current index and recurse.
+            // For Branch/Plural, children use an independent index counter
+            // (same as branch props) so they don't inflate sibling indices.
+            // This matches the compiler's id.copy() behavior.
             const currentIndex = indexObject.index;
-            const children = handleChildren(props?.children === undefined ? null : props?.children);
+            const isBranching = type === BRANCH_COMPONENT || type === PLURAL_COMPONENT;
+            let children;
+            if (isBranching) {
+                const savedIndex = indexObject.index;
+                children = handleChildren(props?.children === undefined ? null : props?.children);
+                indexObject.index = savedIndex;
+            }
+            else {
+                children = handleChildren(props?.children === undefined ? null : props?.children);
+            }
             // Enforce boolean rendering behavior
             // <T>{true}</T> -> true <- this is a boolean value, not a string
             // <T>{false}</T> -> nothing

package/dist/react/jsx/utils/jsxParsing/autoInsertion.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Auto JSX Insertion for CLI extraction.
+ *
+ * Inserts <T> and <Var> JSX elements into the AST so the extraction pipeline
+ * can process them as if the user wrote them. This operates on raw JSX syntax
+ * (JSXElement, JSXText, JSXExpressionContainer) — NOT compiled jsx() calls.
+ *
+ * Rules follow JSX_INSERTION_RULES.md from the compiler package.
+ */
+import * as t from '@babel/types';
+/** Check if a node was auto-inserted */
+export declare function isAutoInserted(node: t.Node): boolean;
+/**
+ * Ensure GtInternalTranslateJsx and GtInternalVar are imported in the AST.
+ * Always adds: import { GtInternalTranslateJsx, GtInternalVar } from 'gt-react/browser';
+ * These are distinct from user T/Var so there's no ambiguity.
+ *
+ * Updates importAliases in-place.
+ */
+export declare function ensureTAndVarImported(ast: t.File, importAliases: Record<string, string>): void;
+/**
+ * Traverse the AST and insert GtInternalTranslateJsx and GtInternalVar JSX elements following
+ * the insertion rules. Uses deliberate children traversal.
+ *
+ * Every inserted node gets node._autoInserted = true.
+ */
+export declare function autoInsertJsxComponents(ast: t.File, importAliases: Record<string, string>): void;

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

@@ -0,0 +1,427 @@
+/**
+ * Auto JSX Insertion for CLI extraction.
+ *
+ * Inserts <T> and <Var> JSX elements into the AST so the extraction pipeline
+ * can process them as if the user wrote them. This operates on raw JSX syntax
+ * (JSXElement, JSXText, JSXExpressionContainer) — NOT compiled jsx() calls.
+ *
+ * Rules follow JSX_INSERTION_RULES.md from the compiler package.
+ */
+import * as t from '@babel/types';
+import traverseModule from '@babel/traverse';
+const traverse = traverseModule.default || traverseModule;
+import { isStaticExpression } from '../../evaluateJsx.js';
+import { TRANSLATION_COMPONENT, INTERNAL_TRANSLATION_COMPONENT, INTERNAL_VAR_COMPONENT, VARIABLE_COMPONENTS, BRANCH_COMPONENT, PLURAL_COMPONENT, DEFAULT_GT_IMPORT_SOURCE, DERIVE_COMPONENT, STATIC_COMPONENT, BRANCH_CONTROL_PROPS, PLURAL_CONTROL_PROPS, } from '../constants.js';
+/** Tracks which AST nodes were auto-inserted by this module */
+const autoInsertedNodes = new WeakSet();
+/** Check if a node was auto-inserted */
+export function isAutoInserted(node) {
+    return autoInsertedNodes.has(node);
+}
+// ===== Public API ===== //
+/**
+ * Ensure GtInternalTranslateJsx and GtInternalVar are imported in the AST.
+ * Always adds: import { GtInternalTranslateJsx, GtInternalVar } from 'gt-react/browser';
+ * These are distinct from user T/Var so there's no ambiguity.
+ *
+ * Updates importAliases in-place.
+ */
+export function ensureTAndVarImported(ast, importAliases) {
+    // Check if internal components are already imported
+    const hasInternalT = Object.values(importAliases).includes(INTERNAL_TRANSLATION_COMPONENT);
+    const hasInternalVar = Object.values(importAliases).includes(INTERNAL_VAR_COMPONENT);
+    if (hasInternalT && hasInternalVar)
+        return;
+    const specifiers = [];
+    if (!hasInternalT) {
+        specifiers.push(t.importSpecifier(t.identifier(INTERNAL_TRANSLATION_COMPONENT), t.identifier(INTERNAL_TRANSLATION_COMPONENT)));
+        importAliases[INTERNAL_TRANSLATION_COMPONENT] =
+            INTERNAL_TRANSLATION_COMPONENT;
+    }
+    if (!hasInternalVar) {
+        specifiers.push(t.importSpecifier(t.identifier(INTERNAL_VAR_COMPONENT), t.identifier(INTERNAL_VAR_COMPONENT)));
+        importAliases[INTERNAL_VAR_COMPONENT] = INTERNAL_VAR_COMPONENT;
+    }
+    const importDecl = t.importDeclaration(specifiers, t.stringLiteral(DEFAULT_GT_IMPORT_SOURCE));
+    traverse(ast, {
+        Program(path) {
+            path.unshiftContainer('body', importDecl);
+            path.stop();
+        },
+    });
+}
+/**
+ * Traverse the AST and insert GtInternalTranslateJsx and GtInternalVar JSX elements following
+ * the insertion rules. Uses deliberate children traversal.
+ *
+ * Every inserted node gets node._autoInserted = true.
+ */
+export function autoInsertJsxComponents(ast, importAliases) {
+    const processedNodes = new WeakSet();
+    const tLocalName = getLocalName(importAliases, INTERNAL_TRANSLATION_COMPONENT);
+    const varLocalName = getLocalName(importAliases, INTERNAL_VAR_COMPONENT);
+    traverse(ast, {
+        JSXElement(path) {
+            if (processedNodes.has(path.node))
+                return;
+            processJsxElement({
+                path,
+                insideAutoT: false,
+                importAliases,
+                processedNodes,
+                tLocalName,
+                varLocalName,
+            });
+        },
+        JSXFragment(path) {
+            if (processedNodes.has(path.node))
+                return;
+            processJsxFragment({
+                path,
+                insideAutoT: false,
+                importAliases,
+                processedNodes,
+                tLocalName,
+                varLocalName,
+            });
+        },
+    });
+}
+function processJsxElement({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, }) {
+    processedNodes.add(path.node);
+    // Get component type
+    const typeName = getElementTypeName(path.node);
+    const canonicalName = typeName ? importAliases[typeName] : undefined;
+    // User T → mark all descendants, hands off
+    if (canonicalName === TRANSLATION_COMPONENT) {
+        markDescendantJsx(path, processedNodes);
+        return;
+    }
+    // Branch/Plural/Derive/Static → opaque, process props for dynamic Var
+    // Must be checked BEFORE user variable check because Derive/Static are in VARIABLE_COMPONENTS
+    if (canonicalName === BRANCH_COMPONENT ||
+        canonicalName === PLURAL_COMPONENT ||
+        canonicalName === DERIVE_COMPONENT ||
+        canonicalName === STATIC_COMPONENT) {
+        if (!insideAutoT) {
+            // Root-level opaque component — wrap in _T
+            const tWrapper = createTWrapper([path.node], tLocalName);
+            processedNodes.add(tWrapper);
+            path.replaceWith(tWrapper);
+        }
+        processOpaqueComponentProps({
+            path,
+            insideAutoT: true,
+            importAliases,
+            processedNodes,
+            tLocalName,
+            varLocalName,
+            canonicalName,
+        });
+        return;
+    }
+    // User Var/Num/Currency/DateTime → mark descendants, hands off
+    if (canonicalName && VARIABLE_COMPONENTS.includes(canonicalName)) {
+        markDescendantJsx(path, processedNodes);
+        return;
+    }
+    // Process children
+    processElementChildren({
+        path,
+        insideAutoT,
+        importAliases,
+        processedNodes,
+        tLocalName,
+        varLocalName,
+    });
+}
+function processJsxFragment({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, }) {
+    processedNodes.add(path.node);
+    // Fragments are treated like regular elements
+    processFragmentChildren({
+        path,
+        insideAutoT,
+        importAliases,
+        processedNodes,
+        tLocalName,
+        varLocalName,
+    });
+}
+// ===== Children processing ===== //
+function processElementChildren({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, }) {
+    const children = path.node.children;
+    const ctx = {
+        insideAutoT,
+        importAliases,
+        processedNodes,
+        tLocalName,
+        varLocalName,
+    };
+    const hasText = hasTranslatableText(children);
+    const hasOpaque = hasOpaqueGTChild(children, importAliases);
+    const shouldClaimT = !insideAutoT && (hasText || hasOpaque);
+    if (shouldClaimT) {
+        // Process children: wrap dynamic expressions in Var, recurse into child elements
+        const childPaths = path.get('children');
+        for (const childPath of childPaths) {
+            processChild(childPath, { ...ctx, insideAutoT: true });
+        }
+        // Wrap all children in <T>
+        wrapChildrenInT(path, tLocalName, processedNodes);
+    }
+    else if (insideAutoT) {
+        // Inside a T region: wrap dynamic expressions, recurse
+        const childPaths = path.get('children');
+        for (const childPath of childPaths) {
+            processChild(childPath, ctx);
+        }
+    }
+    else {
+        // No text, no opaque, not inside T: just recurse into child elements
+        const childPaths = path.get('children');
+        for (const childPath of childPaths) {
+            if (childPath.isJSXElement() && !processedNodes.has(childPath.node)) {
+                processJsxElement({ path: childPath, ...ctx });
+            }
+            else if (childPath.isJSXFragment() &&
+                !processedNodes.has(childPath.node)) {
+                processJsxFragment({ path: childPath, ...ctx });
+            }
+        }
+    }
+}
+function processFragmentChildren({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, }) {
+    const children = path.node.children;
+    const ctx = {
+        insideAutoT,
+        importAliases,
+        processedNodes,
+        tLocalName,
+        varLocalName,
+    };
+    const hasText = hasTranslatableText(children);
+    const hasOpaque = hasOpaqueGTChild(children, importAliases);
+    const shouldClaimT = !insideAutoT && (hasText || hasOpaque);
+    if (shouldClaimT) {
+        const childPaths = path.get('children');
+        for (const childPath of childPaths) {
+            processChild(childPath, { ...ctx, insideAutoT: true });
+        }
+        wrapFragmentChildrenInT(path, tLocalName, processedNodes);
+    }
+    else if (insideAutoT) {
+        const childPaths = path.get('children');
+        for (const childPath of childPaths) {
+            processChild(childPath, ctx);
+        }
+    }
+    else {
+        const childPaths = path.get('children');
+        for (const childPath of childPaths) {
+            if (childPath.isJSXElement() && !processedNodes.has(childPath.node)) {
+                processJsxElement({ path: childPath, ...ctx });
+            }
+            else if (childPath.isJSXFragment() &&
+                !processedNodes.has(childPath.node)) {
+                processJsxFragment({ path: childPath, ...ctx });
+            }
+        }
+    }
+}
+function processChild(childPath, ctx) {
+    if (childPath.isJSXElement() && !ctx.processedNodes.has(childPath.node)) {
+        processJsxElement({ path: childPath, ...ctx });
+    }
+    else if (childPath.isJSXFragment() &&
+        !ctx.processedNodes.has(childPath.node)) {
+        processJsxFragment({ path: childPath, ...ctx });
+    }
+    else if (childPath.isJSXExpressionContainer() &&
+        ctx.insideAutoT &&
+        needsVarWrapping(childPath.node)) {
+        // Wrap dynamic expression in <Var>
+        const varWrapper = createVarWrapper(childPath.node, ctx.varLocalName, ctx.processedNodes);
+        childPath.replaceWith(varWrapper);
+        ctx.processedNodes.add(varWrapper);
+    }
+}
+// ===== Opaque component props ===== //
+function processOpaqueComponentProps({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, canonicalName, }) {
+    // Branch/Plural children (fallback content) — process element-by-element before marking
+    if (insideAutoT &&
+        (canonicalName === BRANCH_COMPONENT || canonicalName === PLURAL_COMPONENT)) {
+        const childPaths = path.get('children');
+        for (const childPath of childPaths) {
+            processChild(childPath, {
+                insideAutoT: true,
+                importAliases,
+                processedNodes,
+                tLocalName,
+                varLocalName,
+            });
+        }
+    }
+    if (!insideAutoT) {
+        markDescendantJsx(path, processedNodes);
+        return;
+    }
+    const ctx = {
+        insideAutoT: true,
+        importAliases,
+        processedNodes,
+        tLocalName,
+        varLocalName,
+    };
+    // Wrap dynamic prop values in <Var>, skipping control props.
+    // This must happen BEFORE markDescendantJsx so that JSX inside auto-inserted
+    // _Var wrappers stays unmarked for the top-level visitor to process independently.
+    const attrs = path.get('openingElement').get('attributes');
+    for (const attrPath of attrs) {
+        if (!attrPath.isJSXAttribute())
+            continue;
+        // Determine prop name and skip control props
+        const nameNode = attrPath.node.name;
+        const propName = t.isJSXIdentifier(nameNode) ? nameNode.name : null;
+        if (isControlProp(canonicalName, propName))
+            continue;
+        const valuePath = attrPath.get('value');
+        if (!valuePath.isJSXExpressionContainer())
+            continue;
+        const expr = valuePath.node.expression;
+        // Content prop with JSX value — recurse into children for Var-wrapping
+        if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
+            const exprPath = valuePath.get('expression');
+            if (exprPath.isJSXElement() || exprPath.isJSXFragment()) {
+                const childPaths = exprPath.get('children');
+                for (const childPath of childPaths) {
+                    processChild(childPath, ctx);
+                }
+            }
+            continue;
+        }
+        // Non-JSX dynamic value — wrap in Var
+        if (needsVarWrapping(valuePath.node)) {
+            const varWrapper = createVarWrapper(valuePath.node, varLocalName, processedNodes);
+            valuePath.replaceWith(varWrapper);
+            processedNodes.add(varWrapper);
+        }
+    }
+    // Mark remaining descendant JSX as processed, but skip auto-inserted nodes
+    // so the top-level visitor can still discover JSX inside _Var wrappers.
+    // For Derive/Static, only mark props — leave children unmarked so the
+    // top-level visitor can independently process them (e.g. Branch/Plural
+    // inside Derive should get their own _T, matching compiler behavior).
+    if (canonicalName === DERIVE_COMPONENT ||
+        canonicalName === STATIC_COMPONENT) {
+        for (const attrPath of path.get('openingElement').get('attributes')) {
+            attrPath.traverse({
+                JSXElement(childPath) {
+                    processedNodes.add(childPath.node);
+                },
+                JSXFragment(childPath) {
+                    processedNodes.add(childPath.node);
+                },
+            });
+        }
+    }
+    else {
+        markDescendantJsx(path, processedNodes);
+    }
+}
+function isControlProp(canonicalName, propName) {
+    if (!propName)
+        return false;
+    if (canonicalName === BRANCH_COMPONENT) {
+        return BRANCH_CONTROL_PROPS.has(propName) || propName.startsWith('data-');
+    }
+    if (canonicalName === PLURAL_COMPONENT) {
+        return PLURAL_CONTROL_PROPS.has(propName);
+    }
+    return false;
+}
+// ===== Helper functions ===== //
+function getElementTypeName(element) {
+    const name = element.openingElement.name;
+    if (t.isJSXIdentifier(name))
+        return name.name;
+    return null;
+}
+function getLocalName(importAliases, canonicalName) {
+    const entry = Object.entries(importAliases).find(([, v]) => v === canonicalName);
+    return entry ? entry[0] : canonicalName;
+}
+function hasTranslatableText(children) {
+    return children.some((child) => t.isJSXText(child) && child.value.trim().length > 0);
+}
+function hasOpaqueGTChild(children, importAliases) {
+    return children.some((child) => {
+        if (!t.isJSXElement(child))
+            return false;
+        const typeName = getElementTypeName(child);
+        if (!typeName)
+            return false;
+        const canonical = importAliases[typeName];
+        return (canonical === BRANCH_COMPONENT ||
+            canonical === PLURAL_COMPONENT ||
+            canonical === DERIVE_COMPONENT ||
+            canonical === STATIC_COMPONENT);
+    });
+}
+function needsVarWrapping(container) {
+    const expr = container.expression;
+    if (t.isJSXEmptyExpression(expr))
+        return false;
+    // Use isStaticExpression to check — if static, no wrapping needed
+    const analysis = isStaticExpression(expr, true);
+    if (analysis.isStatic)
+        return false;
+    // JSX elements/fragments inside expressions are not dynamic — they're valid children
+    if (t.isJSXElement(expr) || t.isJSXFragment(expr))
+        return false;
+    return true;
+}
+// ===== AST construction ===== //
+function createTWrapper(children, tName) {
+    const element = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(tName), []), t.jsxClosingElement(t.jsxIdentifier(tName)), children);
+    autoInsertedNodes.add(element);
+    return element;
+}
+function createVarWrapper(child, varName, processedNodes) {
+    const varElement = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(varName), []), t.jsxClosingElement(t.jsxIdentifier(varName)), [child]);
+    autoInsertedNodes.add(varElement);
+    processedNodes.add(varElement);
+    return t.jsxExpressionContainer(varElement);
+}
+function wrapChildrenInT(elementPath, tName, processedNodes) {
+    const children = [...elementPath.node.children];
+    const tWrapper = createTWrapper(children, tName);
+    processedNodes.add(tWrapper);
+    elementPath.node.children = [tWrapper];
+}
+function wrapFragmentChildrenInT(fragmentPath, tName, processedNodes) {
+    const children = [...fragmentPath.node.children];
+    const tWrapper = createTWrapper(children, tName);
+    processedNodes.add(tWrapper);
+    fragmentPath.node.children = [tWrapper];
+}
+// ===== Marking descendants as processed ===== //
+function markDescendantJsx(path, processedNodes) {
+    path.traverse({
+        JSXElement(childPath) {
+            // Don't mark JSX inside auto-inserted _Var — the top-level visitor
+            // needs to find and process those independently
+            if (autoInsertedNodes.has(childPath.node)) {
+                childPath.skip();
+                return;
+            }
+            processedNodes.add(childPath.node);
+        },
+        JSXFragment(childPath) {
+            if (autoInsertedNodes.has(childPath.node)) {
+                childPath.skip();
+                return;
+            }
+            processedNodes.add(childPath.node);
+        },
+    });
+}

package/dist/react/jsx/utils/jsxParsing/parseJsx.d.ts

@@ -11,6 +11,7 @@ type ConfigOptions = {
     pkgs: GTLibrary[];
     file: string;
     includeSourceCodeContext?: boolean;
+    enableAutoJsxInjection?: boolean;
 };
 /**
  * Collectors for errors, warnings, and unwrapped expressions.

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

@@ -6,10 +6,10 @@ import * as t from '@babel/types';
 import fs from 'node:fs';
 import { parse } from '@babel/parser';
 import addGTIdentifierToSyntaxTree from './addGTIdentifierToSyntaxTree.js';
-import { warnHasUnwrappedExpressionSync, warnNestedTComponent, warnFunctionNotFoundSync, warnMissingReturnSync, warnDuplicateFunctionDefinitionSync, warnInvalidDeriveInitSync, warnRecursiveFunctionCallSync, warnDataAttrOnBranch, } from '../../../../console/index.js';
+import { warnHasUnwrappedExpressionSync, warnNestedTComponent, warnFunctionNotFoundSync, warnMissingReturnSync, warnDuplicateFunctionDefinitionSync, warnInvalidDeriveInitSync, warnRecursiveFunctionCallSync, warnDataAttrOnBranch, warnNestedInternalTComponent, } from '../../../../console/index.js';
 import { isAcceptedPluralForm } from 'generaltranslation/internal';
 import { isStaticExpression } from '../../evaluateJsx.js';
-import { DATA_ATTR_PREFIX, STATIC_COMPONENT, DERIVE_COMPONENT, TRANSLATION_COMPONENT, VARIABLE_COMPONENTS, } from '../constants.js';
+import { DATA_ATTR_PREFIX, STATIC_COMPONENT, DERIVE_COMPONENT, TRANSLATION_COMPONENT, INTERNAL_TRANSLATION_COMPONENT, VARIABLE_COMPONENTS, } from '../constants.js';
 import { HTML_CONTENT_PROPS } from 'generaltranslation/types';
 import { resolveImportPath } from '../resolveImportPath.js';
 import traverseModule from '@babel/traverse';
@@ -20,6 +20,7 @@ import { handleChildrenWhitespace } from './handleChildrenWhitespace.js';
 import { isElementNode } from './types.js';
 import { multiplyJsxTree } from './multiplication/multiplyJsxTree.js';
 import { removeNullChildrenFields } from './removeNullChildrenFields.js';
+import { ensureTAndVarImported, autoInsertJsxComponents, } from './autoInsertion.js';
 import path from 'node:path';
 import { extractSourceCode } from '../extractSourceCode.js';
 import { SURROUNDING_LINE_COUNT } from '../../../../utils/constants.js';
@@ -145,9 +146,53 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inDerive, config,
         }
         // Convert from alias to original name
         const componentType = config.importAliases[typeName ?? ''];
-        if (componentType === TRANSLATION_COMPONENT && insideT) {
+        // When enableAutoJsxInjection is on and we're inside a Derive context,
+        // any auto-inserted T component will be stripped at runtime by
+        // removeInjectedT. Unwrap it transparently — process the T's children
+        // as if the T wasn't there. Check this BEFORE the nested-T warning
+        // so we don't emit spurious errors for expected auto-inserted nesting.
+        if (componentType === INTERNAL_TRANSLATION_COMPONENT &&
+            inDerive &&
+            config.enableAutoJsxInjection) {
+            const childResults = [];
+            const helperChildren = helperPath.get('children');
+            for (let i = 0; i < element.children.length; i++) {
+                const child = element.children[i];
+                const helperChild = helperChildren[i];
+                const result = buildJSXTree({
+                    node: child,
+                    helperPath: helperChild,
+                    scopeNode,
+                    insideT: true,
+                    inDerive: true,
+                    config,
+                    state,
+                    output,
+                });
+                if (result !== null) {
+                    if (Array.isArray(result)) {
+                        childResults.push(...result);
+                    }
+                    else {
+                        childResults.push(result);
+                    }
+                }
+            }
+            if (childResults.length === 0)
+                return null;
+            if (childResults.length === 1)
+                return childResults[0];
+            // Return array — callers flatten this into parent's children
+            return childResults;
+        }
+        if ((componentType === TRANSLATION_COMPONENT ||
+            componentType === INTERNAL_TRANSLATION_COMPONENT) &&
+            insideT) {
             // Add warning: Nested <T> components are allowed, but they are advised against
             output.warnings.add(warnNestedTComponent(config.file, `${element.loc?.start?.line}:${element.loc?.start?.column}`));
+            if (componentType === INTERNAL_TRANSLATION_COMPONENT) {
+                output.errors.push(warnNestedInternalTComponent(config.file, `${element.loc?.start?.line}:${element.loc?.start?.column}`));
+            }
         }
         // If this JSXElement is one of the recognized variable components,
         const elementIsVariable = VARIABLE_COMPONENTS.includes(componentType);
@@ -240,7 +285,13 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inDerive, config,
                         state,
                         output,
                     });
-                    childrenArray.push(result);
+                    // Flatten array results from _T transparency unwrap inside Derive
+                    if (Array.isArray(result)) {
+                        childrenArray.push(...result);
+                    }
+                    else {
+                        childrenArray.push(result);
+                    }
                 }
                 if (childrenArray.length) {
                     results.props.children = childrenArray;
@@ -256,16 +307,22 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inDerive, config,
             };
         }
         const children = element.children
-            .map((child, index) => buildJSXTree({
-            node: child,
-            insideT: true,
-            inDerive: inDerive,
-            scopeNode,
-            helperPath: helperPath.get('children')[index],
-            config,
-            state,
-            output,
-        }))
+            .flatMap((child, index) => {
+            const result = buildJSXTree({
+                node: child,
+                insideT: true,
+                inDerive: inDerive,
+                scopeNode,
+                helperPath: helperPath.get('children')[index],
+                config,
+                state,
+                output,
+            });
+            // Flatten array results from _T transparency unwrap inside Derive
+            if (Array.isArray(result))
+                return result;
+            return [result];
+        })
             .filter((child) => child !== null && child !== '');
         if (children.length === 1) {
             props.children = children[0];
@@ -284,16 +341,22 @@ function buildJSXTree({ node, helperPath, scopeNode, insideT, inDerive, config,
     // If it's a JSX fragment
     else if (t.isJSXFragment(node)) {
         const children = node.children
-            .map((child, index) => buildJSXTree({
-            node: child,
-            insideT: true,
-            inDerive: inDerive,
-            scopeNode,
-            helperPath: helperPath.get('children')[index],
-            config,
-            state,
-            output,
-        }))
+            .flatMap((child, index) => {
+            const result = buildJSXTree({
+                node: child,
+                insideT: true,
+                inDerive: inDerive,
+                scopeNode,
+                helperPath: helperPath.get('children')[index],
+                config,
+                state,
+                output,
+            });
+            // Flatten array results from _T transparency unwrap inside Derive
+            if (Array.isArray(result))
+                return result;
+            return [result];
+        })
             .filter((child) => child !== null && child !== '');
         const props = {};
         if (children.length === 1) {
@@ -405,7 +468,9 @@ function parseJSXElement({ node, originalName, scopeNode, updates, config, state
     const name = openingElement.name;
     // Only proceed if it's <T> ...
     // TODO: i don't think this condition is needed anymore
-    if (!(name.type === 'JSXIdentifier' && originalName === TRANSLATION_COMPONENT)) {
+    if (!(name.type === 'JSXIdentifier' &&
+        (originalName === TRANSLATION_COMPONENT ||
+            originalName === INTERNAL_TRANSLATION_COMPONENT))) {
         return;
     }
     const componentErrors = [];
@@ -477,7 +542,15 @@ function parseJSXElement({ node, originalName, scopeNode, updates, config, state
     // TODO: do this in parallel
     const minifiedTress = [];
     for (const multipliedTree of multipliedTrees) {
-        const minifiedTree = addGTIdentifierToSyntaxTree(multipliedTree);
+        // Build set of confirmed GT variable names from importAliases.
+        // Only pass when enableAutoJsxInjection is on, to avoid breaking
+        // existing behavior where importAliases may be incomplete.
+        const gtVariableNames = config.enableAutoJsxInjection
+            ? new Set(Object.values(config.importAliases).filter((name) => VARIABLE_COMPONENTS.includes(name) &&
+                name !== DERIVE_COMPONENT &&
+                name !== STATIC_COMPONENT))
+            : undefined;
+        const minifiedTree = addGTIdentifierToSyntaxTree(multipliedTree, 0, gtVariableNames);
         minifiedTress.push(Array.isArray(minifiedTree) && minifiedTree.length === 1
             ? minifiedTree[0]
             : minifiedTree);
@@ -620,7 +693,19 @@ function processFunctionInFile({ config, state, output, filePath, functionName,
             sourceType: 'module',
             plugins: ['jsx', 'typescript'],
         });
-        const { importAliases } = getPathsAndAliases(ast, config.pkgs);
+        const pathsResult = getPathsAndAliases(ast, config.pkgs);
+        const importAliases = { ...pathsResult.importAliases };
+        // Merge translation component names into importAliases so
+        // autoInsertJsxComponents can recognize user T/Var and skip them
+        for (const { localName, originalName, } of pathsResult.translationComponentPaths) {
+            importAliases[localName] = originalName;
+        }
+        // Auto-inject T/Var into the cross-file AST when enabled,
+        // so that Derive extraction sees the same structure as same-file
+        if (config.enableAutoJsxInjection) {
+            ensureTAndVarImported(ast, importAliases);
+            autoInsertJsxComponents(ast, importAliases);
+        }
         // Collect all imports in this file to track cross-file function calls
         let importedFunctionsMap = new Map();
         traverse(ast, {
@@ -644,6 +729,7 @@ function processFunctionInFile({ config, state, output, filePath, functionName,
                             parsingOptions: config.parsingOptions,
                             pkgs: config.pkgs,
                             file: filePath,
+                            enableAutoJsxInjection: config.enableAutoJsxInjection,
                         },
                         state: {
                             ...state,
@@ -669,6 +755,7 @@ function processFunctionInFile({ config, state, output, filePath, functionName,
                             parsingOptions: config.parsingOptions,
                             pkgs: config.pkgs,
                             file: filePath,
+                            enableAutoJsxInjection: config.enableAutoJsxInjection,
                         },
                         state: {
                             ...state,
@@ -716,6 +803,7 @@ function processFunctionInFile({ config, state, output, filePath, functionName,
                             parsingOptions: config.parsingOptions,
                             pkgs: config.pkgs,
                             file: filePath,
+                            enableAutoJsxInjection: config.enableAutoJsxInjection,
                         },
                         state: {
                             ...state,
@@ -760,13 +848,19 @@ function processFunctionDeclarationNodePath({ config, state, output, path, }) {
             if (!returnNodePath.isExpression()) {
                 return;
             }
-            result.branches.push(processDeriveExpression({
+            const deriveResult = processDeriveExpression({
                 config,
                 state,
                 output,
                 expressionNodePath: returnNodePath,
                 scopeNode: returnPath,
-            }));
+            });
+            if (Array.isArray(deriveResult)) {
+                result.branches.push(...deriveResult);
+            }
+            else {
+                result.branches.push(deriveResult);
+            }
         },
     });
     if (result.branches.length === 0) {
@@ -794,13 +888,19 @@ function processVariableDeclarationNodePath({ config, state, output, functionNam
     const bodyNodePath = arrowFunctionPath.get('body');
     if (bodyNodePath.isExpression()) {
         // process expression return
-        result.branches.push(processDeriveExpression({
+        const deriveResult = processDeriveExpression({
             config,
             state,
             output,
             expressionNodePath: bodyNodePath,
             scopeNode: arrowFunctionPath,
-        }));
+        });
+        if (Array.isArray(deriveResult)) {
+            result.branches.push(...deriveResult);
+        }
+        else {
+            result.branches.push(deriveResult);
+        }
     }
     else {
         // search for a return statement
@@ -813,13 +913,19 @@ function processVariableDeclarationNodePath({ config, state, output, functionNam
                 if (!returnNodePath.isExpression()) {
                     return;
                 }
-                result.branches.push(processDeriveExpression({
+                const deriveResult = processDeriveExpression({
                     config,
                     state,
                     output,
                     expressionNodePath: returnNodePath,
                     scopeNode: returnPath,
-                }));
+                });
+                if (Array.isArray(deriveResult)) {
+                    result.branches.push(...deriveResult);
+                }
+                else {
+                    result.branches.push(deriveResult);
+                }
             },
         });
     }
@@ -904,13 +1010,16 @@ function processDeriveExpression({ config, state, output, expressionNodePath, sc
         const alternateNodePath = expressionNodePath.get('alternate');
         const result = {
             nodeType: 'multiplication',
-            branches: [consequentNodePath, alternateNodePath].map((expressionNodePath) => processDeriveExpression({
-                config,
-                state,
-                output,
-                scopeNode,
-                expressionNodePath,
-            })),
+            branches: [consequentNodePath, alternateNodePath].flatMap((expressionNodePath) => {
+                const r = processDeriveExpression({
+                    config,
+                    state,
+                    output,
+                    scopeNode,
+                    expressionNodePath,
+                });
+                return Array.isArray(r) ? r : [r];
+            }),
         };
         return result;
     }

package/dist/react/parse/createInlineUpdates.js

@@ -8,6 +8,10 @@ import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
 import { getPathsAndAliases } from '../jsx/utils/getPathsAndAliases.js';
 import { GT_LIBRARIES_UPSTREAM, REACT_LIBRARIES, } from '../../types/libraries.js';
 import { calculateHashes, dedupeUpdates, linkDeriveUpdates, } from '../../extraction/postProcess.js';
+import { ensureTAndVarImported, autoInsertJsxComponents, } from '../jsx/utils/jsxParsing/autoInsertion.js';
+import { INTERNAL_TRANSLATION_COMPONENT } from '../jsx/utils/constants.js';
+import traverseModule from '@babel/traverse';
+const traverse = traverseModule.default || traverseModule;
 export async function createInlineUpdates(pkg, validate, filePatterns, parsingFlags, parsingOptions) {
     const updates = [];
     const errors = [];
@@ -46,7 +50,7 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingFl
                 autoDeriveMethod: parsingFlags.autoDerive ? 'AUTO' : 'DISABLED',
             }, { updates, errors, warnings });
         }
-        // Parse <T> components
+        // Parse <T> components — PASS 1: user-written T
         if (REACT_LIBRARIES.includes(pkg)) {
             for (const { localName, path } of translationComponentPaths) {
                 parseTranslationComponent({
@@ -68,6 +72,55 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingFl
                     },
                 });
             }
+            // PASS 2: Auto-inject GtInternalTranslateJsx and GtInternalVar and extract (flag-gated)
+            if (parsingFlags.enableAutoJsxInjection) {
+                // Add translation component names to importAliases so autoInsertJsxComponents
+                // recognizes user T as hands-off (getPathsAndAliases separates them out)
+                for (const { localName, originalName } of translationComponentPaths) {
+                    importAliases[localName] = originalName;
+                }
+                // Ensure GtInternalTranslateJsx and GtInternalVar are imported in the AST
+                ensureTAndVarImported(ast, importAliases);
+                // Insert T/Var into the AST
+                autoInsertJsxComponents(ast, importAliases);
+                // Refresh scope to pick up new T references
+                traverse(ast, {
+                    Program(programPath) {
+                        programPath.scope.crawl();
+                    },
+                });
+                // Re-collect with updated AST
+                const refreshed = getPathsAndAliases(ast, pkgs);
+                // Add translation component names to refreshed aliases so parseJsx
+                // can recognize GtInternalTranslateJsx inside Derive for transparent unwrap
+                for (const { localName: tLocalName, originalName: tOrigName, } of refreshed.translationComponentPaths) {
+                    refreshed.importAliases[tLocalName] = tOrigName;
+                }
+                // Extract only from auto-injected GtInternalTranslateJsx — never re-extract user T
+                for (const { localName, path, originalName, } of refreshed.translationComponentPaths) {
+                    if (originalName !== INTERNAL_TRANSLATION_COMPONENT)
+                        continue;
+                    parseTranslationComponent({
+                        originalName: localName,
+                        localName,
+                        path,
+                        updates,
+                        config: {
+                            importAliases: refreshed.importAliases,
+                            parsingOptions,
+                            pkgs,
+                            file,
+                            includeSourceCodeContext: parsingFlags.includeSourceCodeContext,
+                            enableAutoJsxInjection: true,
+                        },
+                        output: {
+                            errors,
+                            warnings,
+                            unwrappedExpressions: [],
+                        },
+                    });
+                }
+            }
         }
     }
     // Post processing steps:

package/dist/react/utils/getVariableName.d.ts

@@ -4,8 +4,10 @@ import { VariableType } from 'generaltranslation/types';
  */
 export declare const defaultVariableNames: {
     readonly Var: "value";
+    readonly GtInternalVar: "value";
     readonly Num: "n";
     readonly DateTime: "date";
+    readonly RelativeTime: "time";
     readonly Currency: "cost";
 };
 /**

package/dist/react/utils/getVariableName.js

@@ -3,14 +3,18 @@
  */
 export const defaultVariableNames = {
     Var: 'value',
+    GtInternalVar: 'value',
     Num: 'n',
     DateTime: 'date',
+    RelativeTime: 'time',
     Currency: 'cost',
 };
 const minifyVariableTypeMap = {
     Var: 'v',
+    GtInternalVar: 'v',
     Num: 'n',
     DateTime: 'd',
+    RelativeTime: 'rt',
     Currency: 'c',
 };
 /**

package/dist/types/parsing.d.ts

@@ -32,10 +32,12 @@ export type BaseParsingFlags = Record<string, unknown>;
  *
  * @property {boolean} autoDerive - Whether to enable auto-derive for the t() function. (true -> 'AUTO', false -> 'DISABLED' {@link ParsingConfig['autoDeriveMethod']})
  * @property {boolean} includeSourceCodeContext - Include surrounding source code lines as context for translations.
+ * @property {boolean} enableAutoJsxInjection - Whether to enable auto-jsx injection for the internal <_T> and <_Var> components.
  */
 export type GTParsingFlags = BaseParsingFlags & {
     autoDerive: boolean;
     includeSourceCodeContext: boolean;
+    enableAutoJsxInjection: boolean;
 };
 /**
  * Flags for parsing content with each filetype having its own flags

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.14.3",
+  "version": "2.14.4",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -110,8 +110,8 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "@generaltranslation/python-extractor": "0.2.5",
-    "generaltranslation": "8.2.1",
+    "@generaltranslation/python-extractor": "0.2.6",
+    "generaltranslation": "8.2.2",
     "gt-remark": "1.0.7"
   },
   "devDependencies": {