gtx-cli 2.5.0-alpha.3 → 2.5.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # gtx-cli
 
+## 2.5.0
+
+### Minor Changes
+
+- [#788](https://github.com/generaltranslation/gt/pull/788) [`99e4648`](https://github.com/generaltranslation/gt/commit/99e46486ae2046c689e0045372d63c4eb3dc5d48) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - More information: https://https://generaltranslation.com/en-US/blog/gt-next_v6_8_0
+
+  feat: static component
+
+- [#791](https://github.com/generaltranslation/gt/pull/791) [`fee5d4a`](https://github.com/generaltranslation/gt/commit/fee5d4a3d0fd20e0928eebb83201a87289265719) Thanks [@brian-lou](https://github.com/brian-lou)! - Update Notes:
+  https://generaltranslation.com/blog/generaltranslation_v8
+
+  Please update the following packages to the latest version:
+  - generaltranslation: `7.9.1` or later
+  - gtx-cli: `2.4.15` or later
+  - gt-sanity: `1.0.11` or later
+
+  Older versions of these packages may not be compatible with the latest version of the General Translation API and may require updating.
+
+### Patch Changes
+
+- Updated dependencies [[`fee5d4a`](https://github.com/generaltranslation/gt/commit/fee5d4a3d0fd20e0928eebb83201a87289265719)]:
+  - generaltranslation@8.0.0
+
 ## 2.4.15
 
 ### Patch Changes

package/dist/config/generateSettings.js

@@ -158,7 +158,14 @@ export async function generateSettings(flags, cwd = process.cwd()) {
     // Add parsing options if not provided
     mergedOptions.parsingOptions = mergedOptions.parsingOptions || {};
     mergedOptions.parsingOptions.conditionNames = mergedOptions.parsingOptions
-        .conditionNames || ['browser', 'module', 'import', 'require', 'default'];
+        .conditionNames || [
+        'development',
+        'browser',
+        'module',
+        'import',
+        'require',
+        'default',
+    ];
     // Add branch options if not provided
     const branchOptions = mergedOptions.branchOptions || {};
     branchOptions.enabled = flags.enableBranching ?? false;

package/dist/console/colors.d.ts

@@ -1,5 +1,6 @@
 export declare function colorizeFilepath(filepath: string): string;
 export declare function colorizeComponent(component: string): string;
+export declare function colorizeFunctionName(functionName: string): string;
 export declare function colorizeIdString(id: string): string;
 export declare function colorizeContent(content: string): string;
 export declare function colorizeLine(line: string): string;

package/dist/console/colors.js

@@ -5,6 +5,9 @@ export function colorizeFilepath(filepath) {
 export function colorizeComponent(component) {
     return chalk.yellow(component);
 }
+export function colorizeFunctionName(functionName) {
+    return chalk.yellow(functionName);
+}
 export function colorizeIdString(id) {
     return chalk.yellow(id);
 }

package/dist/console/index.d.ts

@@ -1,6 +1,9 @@
 export declare const warnApiKeyInConfigSync: (optionsFilepath: string) => string;
 export declare const warnVariablePropSync: (file: string, attrName: string, value: string, location?: string) => string;
+export declare const warnInvalidReturnSync: (file: string, functionName: string, expression: string, location?: string) => string;
+export declare const warnMissingReturnSync: (file: string, functionName: string, location?: string) => 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 warnNonStaticExpressionSync: (file: string, attrName: string, value: string, location?: string) => string;
 export declare const warnInvalidIcuSync: (file: string, value: string, error: string, location?: string) => string;
@@ -10,6 +13,11 @@ export declare const warnAsyncUseGT: (file: string, location?: string) => string
 export declare const warnSyncGetGT: (file: string, location?: string) => string;
 export declare const warnTernarySync: (file: string, location?: string) => string;
 export declare const withLocation: (file: string, message: string, location?: string) => string;
+export declare const warnInvalidStaticChildSync: (file: string, location?: string) => string;
+export declare const warnFunctionNotFoundSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnDuplicateFunctionDefinitionSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnInvalidStaticInitSync: (file: string, functionName: string, location?: string) => string;
+export declare const warnRecursiveFunctionCallSync: (file: string, functionName: string, location?: string) => string;
 export declare const noLocalesError = "No locales found! Please provide a list of locales to translate to, or specify them in your gt.config.json file.";
 export declare const noDefaultLocaleError = "No default locale found! Please provide a default locale, or specify it in your gt.config.json file.";
 export declare const noFilesError = "Incorrect or missing files configuration! Please make sure your files are configured correctly in your gt.config.json file.";

package/dist/console/index.js

@@ -1,8 +1,15 @@
-import { colorizeFilepath, colorizeComponent, colorizeIdString, colorizeContent, colorizeLine, } from './colors.js';
+import { colorizeFilepath, colorizeComponent, colorizeIdString, colorizeContent, colorizeLine, colorizeFunctionName, } from './colors.js';
+const withWillErrorInNextVersion = (message) => `${message} (This will become an error in the next major version of the CLI.)`;
+// Static function related errors
+const withStaticError = (message) => `<Static> rules violation: ${message}`;
 // Synchronous wrappers for backward compatibility
 export const warnApiKeyInConfigSync = (optionsFilepath) => `${colorizeFilepath(optionsFilepath)}: Your API key is exposed! Please remove it from the file and include it as an environment variable.`;
 export const warnVariablePropSync = (file, attrName, value, location) => withLocation(file, `${colorizeComponent('<T>')} component has dynamic attribute ${colorizeIdString(attrName)} with value: ${colorizeContent(value)}. Change ${colorizeIdString(attrName)} to ensure this content is translated.`, location);
+export const warnInvalidReturnSync = (file, functionName, expression, location) => withLocation(file, withStaticError(`Function ${colorizeFunctionName(functionName)} does not return a static expression. ${colorizeFunctionName(functionName)} must return either (1) a static string literal, (2) another static function invocation, (3) static JSX content, or (4) a ternary expression. Instead got:\n${colorizeContent(expression)}`), location);
+// TODO: this is temporary until we handle implicit returns
+export const warnMissingReturnSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} is wrapped in ${colorizeComponent('<Static>')} tags but does have an explicit return statement. Static functions must have an explicit return statment.`, location);
 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 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));
@@ -12,7 +19,13 @@ export const warnAsyncUseGT = (file, location) => withLocation(file, `Found useG
 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.)`;
+export const warnInvalidStaticChildSync = (file, location) => withLocation(file, 'Found invalid <Static> invocation. Children must be an expression container with a function invocation. Callee must be a single identifier. (Example: <T> <Static> {getSubject()} </Static> </T>)', location);
+export const warnFunctionNotFoundSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} definition could not be resolved. This might affect translation resolution for this ${colorizeComponent('<T>')} component.`, location);
+export const warnDuplicateFunctionDefinitionSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} is defined multiple times. Only the first definition will be used.`, location);
+export const warnInvalidStaticInitSync = (file, functionName, location) => withLocation(file, withStaticError(`The definition for ${colorizeFunctionName(functionName)} could not be resolved. When using arrow syntax to define a static function, the right hand side or the assignment MUST only contain the arrow function itself and no other expressions.
+Example: ${colorizeContent(`const ${colorizeFunctionName(functionName)} = () => { ... }`)}
+Invalid: ${colorizeContent(`const ${colorizeFunctionName(functionName)} = [() => { ... }][0]`)}`), location);
+export const warnRecursiveFunctionCallSync = (file, functionName, location) => withLocation(file, withStaticError(`Recursive function call detected: ${colorizeFunctionName(functionName)}. A static function use recursive calls to construct its result.`), location);
 // 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

@@ -5,15 +5,18 @@ import * as t from '@babel/types';
  * @returns Whether the node is meaningful
  */
 export declare function isMeaningful(node: t.Node): boolean;
-/**
- * Checks if an expression is static (does not contain any variables which could change at runtime).
- * @param expr - The expression to check
- * @returns An object containing the result of the static check
- */
-export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpression): {
+export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpression, jsxStatic?: false): {
     isStatic: boolean;
     value?: string;
 };
+export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpression, jsxStatic?: true): {
+    isStatic: boolean;
+    value?: string | boolean | null;
+};
+export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpression, jsxStatic?: boolean): {
+    isStatic: boolean;
+    value?: string | boolean | null;
+};
 export declare function isStaticValue(expr: t.Expression | t.JSXEmptyExpression): boolean;
 export declare function isValidIcu(string: string): {
     isValid: boolean;

package/dist/react/jsx/evaluateJsx.js

@@ -33,9 +33,10 @@ export function isMeaningful(node) {
 /**
  * Checks if an expression is static (does not contain any variables which could change at runtime).
  * @param expr - The expression to check
+ * @param ignoreStaticFunction - Whether to ignore static functions
  * @returns An object containing the result of the static check
  */
-export function isStaticExpression(expr) {
+export function isStaticExpression(expr, jsxStatic = false) {
     // Handle empty expressions
     if (t.isJSXEmptyExpression(expr)) {
         return { isStatic: true, value: '' };
@@ -46,7 +47,10 @@ export function isStaticExpression(expr) {
     }
     // Handle template literals without expressions
     if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) {
-        return { isStatic: true, value: expr.quasis[0].value.raw };
+        return {
+            isStatic: true,
+            value: jsxStatic ? expr.quasis[0].value.cooked : expr.quasis[0].value.raw,
+        };
     }
     // Binary expressions are not static
     if (t.isBinaryExpression(expr)) {
@@ -55,19 +59,43 @@ export function isStaticExpression(expr) {
     }
     // Handle parenthesized expressions
     if (t.isParenthesizedExpression(expr)) {
-        return isStaticExpression(expr.expression);
+        return isStaticExpression(expr.expression, jsxStatic);
     }
     // Handle numeric literals by converting them to strings
     if (t.isNumericLiteral(expr)) {
         return { isStatic: true, value: String(expr.value) };
     }
+    // Handle unary expressions by converting them to strings
+    if (t.isUnaryExpression(expr)) {
+        let value;
+        let operator = '';
+        if (expr.operator === '-') {
+            operator = expr.operator;
+        }
+        if (t.isNumericLiteral(expr.argument)) {
+            if (expr.argument.value === 0) {
+                value = '0';
+            }
+            else {
+                value = operator + expr.argument.value.toString();
+            }
+        }
+        else {
+            // invalid
+            return { isStatic: false };
+        }
+        return { isStatic: true, value };
+    }
     // Handle boolean literals by converting them to strings
     if (t.isBooleanLiteral(expr)) {
-        return { isStatic: true, value: String(expr.value) };
+        return {
+            isStatic: true,
+            value: jsxStatic ? expr.value : String(expr.value),
+        };
     }
     // Handle null literal
     if (t.isNullLiteral(expr)) {
-        return { isStatic: true, value: 'null' };
+        return { isStatic: true, value: jsxStatic ? null : 'null' };
     }
     // Not a static expression
     return { isStatic: false };

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

@@ -0,0 +1,9 @@
+import { NodePath } from '@babel/traverse';
+/**
+ * Builds a map of imported function names to their import paths from a given program path.
+ * Handles both named imports and default imports.
+ *
+ * Example: import { getInfo } from './constants' -> Map { 'getInfo' => './constants' }
+ * Example: import utils from './utils' -> Map { 'utils' => './utils' }
+ */
+export declare function buildImportMap(programPath: NodePath): Map<string, string>;

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

@@ -0,0 +1,30 @@
+import * as t from '@babel/types';
+/**
+ * Builds a map of imported function names to their import paths from a given program path.
+ * Handles both named imports and default imports.
+ *
+ * Example: import { getInfo } from './constants' -> Map { 'getInfo' => './constants' }
+ * Example: import utils from './utils' -> Map { 'utils' => './utils' }
+ */
+export function buildImportMap(programPath) {
+    const importMap = new Map();
+    programPath.traverse({
+        ImportDeclaration(importPath) {
+            if (t.isStringLiteral(importPath.node.source)) {
+                const importSource = importPath.node.source.value;
+                importPath.node.specifiers.forEach((spec) => {
+                    if (t.isImportSpecifier(spec) &&
+                        t.isIdentifier(spec.imported) &&
+                        t.isIdentifier(spec.local)) {
+                        importMap.set(spec.local.name, importSource);
+                    }
+                    else if (t.isImportDefaultSpecifier(spec) &&
+                        t.isIdentifier(spec.local)) {
+                        importMap.set(spec.local.name, importSource);
+                    }
+                });
+            }
+        },
+    });
+    return importMap;
+}

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

@@ -3,6 +3,8 @@ export declare const INLINE_TRANSLATION_HOOK = "useGT";
 export declare const INLINE_TRANSLATION_HOOK_ASYNC = "getGT";
 export declare const INLINE_MESSAGE_HOOK = "useMessages";
 export declare const INLINE_MESSAGE_HOOK_ASYNC = "getMessages";
+export declare const TRANSLATION_COMPONENT = "T";
+export declare const STATIC_COMPONENT = "Static";
 export declare const GT_TRANSLATION_FUNCS: string[];
 export declare const VARIABLE_COMPONENTS: string[];
 export declare const GT_ATTRIBUTES_WITH_SUGAR: string[];

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

@@ -3,6 +3,8 @@ export const INLINE_TRANSLATION_HOOK = 'useGT';
 export const INLINE_TRANSLATION_HOOK_ASYNC = 'getGT';
 export const INLINE_MESSAGE_HOOK = 'useMessages';
 export const INLINE_MESSAGE_HOOK_ASYNC = 'getMessages';
+export const TRANSLATION_COMPONENT = 'T';
+export const STATIC_COMPONENT = 'Static';
 // GT translation functions
 export const GT_TRANSLATION_FUNCS = [
     INLINE_TRANSLATION_HOOK,
@@ -10,7 +12,8 @@ export const GT_TRANSLATION_FUNCS = [
     INLINE_MESSAGE_HOOK,
     INLINE_MESSAGE_HOOK_ASYNC,
     MSG_TRANSLATION_HOOK,
-    'T',
+    TRANSLATION_COMPONENT,
+    STATIC_COMPONENT,
     'Var',
     'DateTime',
     'Currency',
@@ -19,7 +22,13 @@ export const GT_TRANSLATION_FUNCS = [
     'Plural',
 ];
 // Valid variable components
-export const VARIABLE_COMPONENTS = ['Var', 'DateTime', 'Currency', 'Num'];
+export const VARIABLE_COMPONENTS = [
+    'Var',
+    'DateTime',
+    'Currency',
+    'Num',
+    STATIC_COMPONENT,
+];
 export const GT_ATTRIBUTES_WITH_SUGAR = ['$id', '$context'];
 export const GT_ATTRIBUTES = ['id', 'context', ...GT_ATTRIBUTES_WITH_SUGAR];
 export function mapAttributeName(attrName) {

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

@@ -0,0 +1,17 @@
+import { NodePath } from '@babel/traverse';
+/**
+ *
+ */
+export declare function getPathsAndAliases(ast: any, pkg: 'gt-react' | 'gt-next'): {
+    importAliases: Record<string, string>;
+    inlineTranslationPaths: Array<{
+        localName: string;
+        path: NodePath;
+        originalName: string;
+    }>;
+    translationComponentPaths: Array<{
+        localName: string;
+        path: NodePath;
+        originalName: string;
+    }>;
+};

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

@@ -0,0 +1,89 @@
+import traverseModule from '@babel/traverse';
+import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_TRANSLATION_HOOK, TRANSLATION_COMPONENT, } from '../../jsx/utils/constants.js';
+import { extractImportName } from './parseAst.js';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+/**
+ *
+ */
+export function getPathsAndAliases(ast, pkg) {
+    // First pass: collect imports and process translation functions
+    const importAliases = {};
+    const inlineTranslationPaths = [];
+    const translationComponentPaths = [];
+    traverse(ast, {
+        ImportDeclaration(path) {
+            if (path.node.source.value.startsWith(pkg)) {
+                const importName = extractImportName(path.node, pkg, GT_TRANSLATION_FUNCS);
+                for (const name of importName) {
+                    if (name.original === INLINE_TRANSLATION_HOOK ||
+                        name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
+                        name.original === INLINE_MESSAGE_HOOK ||
+                        name.original === INLINE_MESSAGE_HOOK_ASYNC ||
+                        name.original === MSG_TRANSLATION_HOOK) {
+                        inlineTranslationPaths.push({
+                            localName: name.local,
+                            path,
+                            originalName: name.original,
+                        });
+                    }
+                    else if (name.original === TRANSLATION_COMPONENT) {
+                        translationComponentPaths.push({
+                            localName: name.local,
+                            path,
+                            originalName: name.original,
+                        });
+                    }
+                    else {
+                        importAliases[name.local] = name.original;
+                    }
+                }
+            }
+        },
+        VariableDeclarator(path) {
+            // Check if the init is a require call
+            if (path.node.init?.type === 'CallExpression' &&
+                path.node.init.callee.type === 'Identifier' &&
+                path.node.init.callee.name === 'require') {
+                // Check if it's requiring our package
+                const args = path.node.init.arguments;
+                if (args.length === 1 &&
+                    args[0].type === 'StringLiteral' &&
+                    args[0].value.startsWith(pkg)) {
+                    const parentPath = path.parentPath;
+                    if (parentPath.isVariableDeclaration()) {
+                        const importName = extractImportName(parentPath.node, pkg, GT_TRANSLATION_FUNCS);
+                        for (const name of importName) {
+                            if (name.original === INLINE_TRANSLATION_HOOK ||
+                                name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
+                                name.original === INLINE_MESSAGE_HOOK ||
+                                name.original === INLINE_MESSAGE_HOOK_ASYNC ||
+                                name.original === MSG_TRANSLATION_HOOK) {
+                                inlineTranslationPaths.push({
+                                    localName: name.local,
+                                    path: parentPath,
+                                    originalName: name.original,
+                                });
+                            }
+                            else if (name.original === TRANSLATION_COMPONENT) {
+                                translationComponentPaths.push({
+                                    localName: name.local,
+                                    path: parentPath,
+                                    originalName: name.original,
+                                });
+                            }
+                            else {
+                                importAliases[name.local] = name.original;
+                            }
+                        }
+                    }
+                }
+            }
+        },
+    });
+    return {
+        importAliases,
+        inlineTranslationPaths,
+        translationComponentPaths,
+    };
+}

package/dist/react/{data-_gt → jsx/utils/jsxParsing}/addGTIdentifierToSyntaxTree.d.ts

@@ -1,8 +1,9 @@
 import { JsxChildren } from 'generaltranslation/types';
+import { MultipliedTreeNode } from './types.js';
 /**
  * Add GT Identifier and minify the tree (recreates addGTIdentifier and writeChildrenAsObjects)
  * @param tree - The tree to add GT identifiers to
  * @param startingIndex - The starting index for GT IDs
  * @returns The tree with GT identifiers added
  */
-export default function addGTIdentifierToSyntaxTree(tree: any, startingIndex?: number): JsxChildren;
+export default function addGTIdentifierToSyntaxTree(tree: MultipliedTreeNode, startingIndex?: number): JsxChildren;

package/dist/react/{data-_gt → jsx/utils/jsxParsing}/addGTIdentifierToSyntaxTree.js

@@ -1,5 +1,5 @@
 import { HTML_CONTENT_PROPS, } from 'generaltranslation/types';
-import { defaultVariableNames, getVariableName, minifyVariableType, } from '../utils/getVariableName.js';
+import { defaultVariableNames, getVariableName, minifyVariableType, } from '../../../utils/getVariableName.js';
 import { isAcceptedPluralForm } from 'generaltranslation/internal';
 /**
  * Construct the data-_gt prop
@@ -55,6 +55,10 @@ function constructGTProp(type, props, id) {
  * @returns The tree with GT identifiers added
  */
 export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
+    // Edge case: boolean or null, just return the tree
+    if (typeof tree === 'boolean' || tree === null) {
+        return tree;
+    }
     // Object to keep track of the current index for GT IDs
     const indexObject = { index: startingIndex };
     /**
@@ -83,12 +87,23 @@ export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
                 };
             }
             // Construct the data-_gt prop
-            const generaltranslation = constructGTProp(type, props, indexObject.index);
+            const generaltranslation = constructGTProp(type, (props || {}), indexObject.index);
+            // Save current index and recurse
+            const currentIndex = indexObject.index;
+            const 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
+            let includeChildren = true;
+            if (typeof children === 'boolean') {
+                // So, technically JsxChildren do include boolean values, but the type is incorrect
+                includeChildren = children !== false;
+            }
             // Return the result
             return {
-                t: type || `C${indexObject.index}`,
-                i: indexObject.index,
-                c: handleChildren(props.children),
+                t: type || `C${currentIndex}`,
+                i: currentIndex,
+                ...(includeChildren && { c: children }),
                 ...(generaltranslation && { d: generaltranslation }),
             };
         }
@@ -104,7 +119,16 @@ export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
      */
     const handleChildren = (children) => {
         return Array.isArray(children)
-            ? children.map(handleSingleChild)
+            ? children.map(handleSingleChild).filter((child) => {
+                // Enforce boolean rendering behavior
+                // <T>{true}{false}{null}</T> -> []
+                if (typeof child === 'boolean' ||
+                    child === null ||
+                    child === undefined) {
+                    return false;
+                }
+                return true;
+            })
             : handleSingleChild(children);
     };
     return handleChildren(tree);

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

@@ -0,0 +1,6 @@
+import { JsxTree, MultiplicationNode, WhitespaceJsxTreeResult, WhitespaceMultiplicationNode } from './types.js';
+export declare function trimJsxStringChild(child: string): string;
+export declare function handleChildrenWhitespace(currentTree: MultiplicationNode['branches'], parentNodeType: 'multiplication'): (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
+export declare function handleChildrenWhitespace(currentTree: MultiplicationNode['branches'], parentNodeType?: 'element' | 'expression' | undefined): WhitespaceJsxTreeResult | WhitespaceMultiplicationNode | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
+export declare function handleChildrenWhitespace(currentTree: MultiplicationNode | JsxTree, parentNodeType?: 'multiplication' | 'element' | 'expression' | undefined): null | WhitespaceJsxTreeResult | WhitespaceMultiplicationNode;
+export declare function handleChildrenWhitespace(currentTree: JsxTree | JsxTree[]): null | WhitespaceJsxTreeResult | WhitespaceJsxTreeResult[];