gt 2.14.35 → 2.14.37

package/dist/react/jsx/wrapJsx.js

@@ -1,387 +1,204 @@
-import * as t from '@babel/types';
-import { isStaticExpression, isStaticValue } from './evaluateJsx.js';
-import { warnTernarySync } from '../../console/index.js';
+import { isStaticExpression, isStaticValue } from "./evaluateJsx.js";
+import { warnTernarySync } from "../../console/index.js";
+import * as t from "@babel/types";
+//#region src/react/jsx/wrapJsx.ts
 function wrapJsxExpression(node, options, isMeaningful, mark) {
-    const expression = t.isParenthesizedExpression(node.expression)
-        ? node.expression.expression
-        : node.expression;
-    // Ignore template literals containing quasis - they should not be counted as meaningful
-    if (t.isTemplateLiteral(expression) && expression.expressions.length > 0) {
-        return {
-            node,
-            hasMeaningfulContent: false,
-            wrappedInT: false,
-        };
-    }
-    // Handle both JSX Elements and Fragments
-    if (t.isJSXElement(expression) ||
-        t.isJSXFragment(expression) ||
-        t.isStringLiteral(expression) ||
-        t.isJSXText(expression) ||
-        t.isTemplateLiteral(expression)) {
-        if (t.isJSXElement(expression) || t.isJSXFragment(expression)) {
-            const result = wrapJsxElement(expression, options, isMeaningful, mark);
-            // re-wrap the result in a JSXExpressionContainer
-            if (t.isParenthesizedExpression(node.expression)) {
-                node.expression.expression = result.node;
-            }
-            else {
-                node.expression = result.node;
-            }
-            return {
-                node,
-                hasMeaningfulContent: result.hasMeaningfulContent,
-                wrappedInT: result.wrappedInT,
-            };
-        }
-        return {
-            node,
-            hasMeaningfulContent: isMeaningful(expression),
-            wrappedInT: false,
-        };
-    }
-    // Handle conditional expressions (ternary)
-    else if (t.isConditionalExpression(expression)) {
-        const consequent = t.isParenthesizedExpression(expression.consequent)
-            ? expression.consequent.expression
-            : expression.consequent;
-        const alternate = t.isParenthesizedExpression(expression.alternate)
-            ? expression.alternate.expression
-            : expression.alternate;
-        // Handle consequent
-        if (t.isJSXElement(consequent) || t.isJSXFragment(consequent)) {
-            const result = handleJsxElement(consequent, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.consequent)) {
-                expression.consequent.expression = result.node;
-            }
-            else {
-                expression.consequent = result.node;
-            }
-            // Warn about ternary (should use branch instead)
-            if (result.wrappedInT && !mark) {
-                options.warnings.push(warnTernarySync(options.file, `${consequent.loc?.start?.line}:${consequent.loc?.start?.column}`));
-            }
-        }
-        else if (t.isConditionalExpression(consequent) ||
-            t.isLogicalExpression(consequent)) {
-            // Recursively handle nested ternary in consequent
-            const consequentResult = wrapJsxExpression(t.jsxExpressionContainer(consequent), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(consequentResult.node) &&
-                t.isExpression(consequentResult.node.expression)) {
-                expression.consequent = consequentResult.node.expression;
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.consequent)) {
-                    expression.consequent.expression = consequentResult.node.expression;
-                }
-                else {
-                    expression.consequent = consequentResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(consequent) &&
-            consequent.expressions.length > 0) {
-            // Ignore template literals in consequent with expressions (${}), don't wrap them
-            // Do nothing
-        }
-        else {
-            if (isStaticValue(consequent) && isMeaningful(consequent)) {
-                const wrapped = wrapExpressionWithT(consequent, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.consequent)) {
-                    expression.consequent.expression = wrapped;
-                }
-                else {
-                    expression.consequent = wrapped;
-                }
-            }
-        }
-        // Handle alternate
-        if (t.isJSXElement(alternate) || t.isJSXFragment(alternate)) {
-            const result = handleJsxElement(alternate, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.alternate)) {
-                expression.alternate.expression = result.node;
-            }
-            else {
-                expression.alternate = result.node;
-            }
-        }
-        else if (t.isConditionalExpression(alternate) ||
-            t.isLogicalExpression(alternate)) {
-            // Recursively handle nested ternary in alternate
-            const alternateResult = wrapJsxExpression(t.jsxExpressionContainer(alternate), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(alternateResult.node) &&
-                t.isExpression(alternateResult.node.expression)) {
-                expression.alternate = alternateResult.node.expression;
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.alternate)) {
-                    expression.alternate.expression = alternateResult.node.expression;
-                }
-                else {
-                    expression.alternate = alternateResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(alternate) &&
-            alternate.expressions.length > 0) {
-            // Ignore template literals in alternate with expressions (${}), don't wrap them
-            // Do nothing
-        }
-        else {
-            if (isStaticValue(alternate) && isMeaningful(alternate)) {
-                const wrapped = wrapExpressionWithT(alternate, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.alternate)) {
-                    expression.alternate.expression = wrapped;
-                }
-                else {
-                    expression.alternate = wrapped;
-                }
-            }
-        }
-    }
-    // Handle logical expressions (&& and ||)
-    else if (t.isLogicalExpression(expression)) {
-        const left = t.isParenthesizedExpression(expression.left)
-            ? expression.left.expression
-            : expression.left;
-        const right = t.isParenthesizedExpression(expression.right)
-            ? expression.right.expression
-            : expression.right;
-        if (t.isJSXElement(left) || t.isJSXFragment(left)) {
-            const result = handleJsxElement(left, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.left)) {
-                expression.left.expression = result.node;
-            }
-            else {
-                expression.left = result.node;
-            }
-        }
-        else if (t.isLogicalExpression(left) || t.isConditionalExpression(left)) {
-            // Recursively handle nested logical expressions
-            const leftResult = wrapJsxExpression(t.jsxExpressionContainer(left), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(leftResult.node) &&
-                t.isExpression(leftResult.node.expression)) {
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.left)) {
-                    expression.left.expression = leftResult.node.expression;
-                }
-                else {
-                    expression.left = leftResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(left) && left.expressions.length > 0) {
-            // Ignore template literals with expressions (${}) in left side of logical expression
-            // Do nothing - don't wrap them
-        }
-        else {
-            if (isStaticValue(left) &&
-                isMeaningful(left) &&
-                expression.operator !== '&&') {
-                const wrapped = wrapExpressionWithT(left, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.left)) {
-                    expression.left.expression = wrapped;
-                }
-                else {
-                    expression.left = wrapped;
-                }
-            }
-        }
-        if (t.isJSXElement(right) || t.isJSXFragment(right)) {
-            const result = handleJsxElement(right, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.right)) {
-                expression.right.expression = result.node;
-            }
-            else {
-                expression.right = result.node;
-            }
-        }
-        else if (t.isLogicalExpression(right) ||
-            t.isConditionalExpression(right)) {
-            // Recursively handle nested logical expressions
-            const rightResult = wrapJsxExpression(t.jsxExpressionContainer(right), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(rightResult.node) &&
-                t.isExpression(rightResult.node.expression)) {
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.right)) {
-                    expression.right.expression = rightResult.node.expression;
-                }
-                else {
-                    expression.right = rightResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(right) && right.expressions.length > 0) {
-            // Ignore template literals with expressions (${}) in right side of logical expression
-            // Do nothing - don't wrap them
-        }
-        else {
-            if (isStaticValue(right) &&
-                isMeaningful(right) &&
-                expression.operator !== '||') {
-                const wrapped = wrapExpressionWithT(right, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.right)) {
-                    expression.right.expression = wrapped;
-                }
-                else {
-                    expression.right = wrapped;
-                }
-            }
-        }
-    }
-    const staticCheck = isStaticExpression(expression);
-    // If the expression is not derivable or if it's already wrapped in T,
-    // wrap with Var
-    if (!staticCheck.isStatic) {
-        return {
-            node: wrapWithVar(node, options, mark),
-            hasMeaningfulContent: false,
-            wrappedInT: false,
-        };
-    }
-    // If it's a derivable expression, check if it's meaningful
-    return {
-        node,
-        hasMeaningfulContent: false,
-        wrappedInT: false,
-    };
+	const expression = t.isParenthesizedExpression(node.expression) ? node.expression.expression : node.expression;
+	if (t.isTemplateLiteral(expression) && expression.expressions.length > 0) return {
+		node,
+		hasMeaningfulContent: false,
+		wrappedInT: false
+	};
+	if (t.isJSXElement(expression) || t.isJSXFragment(expression) || t.isStringLiteral(expression) || t.isJSXText(expression) || t.isTemplateLiteral(expression)) {
+		if (t.isJSXElement(expression) || t.isJSXFragment(expression)) {
+			const result = wrapJsxElement(expression, options, isMeaningful, mark);
+			if (t.isParenthesizedExpression(node.expression)) node.expression.expression = result.node;
+			else node.expression = result.node;
+			return {
+				node,
+				hasMeaningfulContent: result.hasMeaningfulContent,
+				wrappedInT: result.wrappedInT
+			};
+		}
+		return {
+			node,
+			hasMeaningfulContent: isMeaningful(expression),
+			wrappedInT: false
+		};
+	} else if (t.isConditionalExpression(expression)) {
+		const consequent = t.isParenthesizedExpression(expression.consequent) ? expression.consequent.expression : expression.consequent;
+		const alternate = t.isParenthesizedExpression(expression.alternate) ? expression.alternate.expression : expression.alternate;
+		if (t.isJSXElement(consequent) || t.isJSXFragment(consequent)) {
+			const result = handleJsxElement(consequent, options, isMeaningful);
+			if (t.isParenthesizedExpression(expression.consequent)) expression.consequent.expression = result.node;
+			else expression.consequent = result.node;
+			if (result.wrappedInT && !mark) options.warnings.push(warnTernarySync(options.file, `${consequent.loc?.start?.line}:${consequent.loc?.start?.column}`));
+		} else if (t.isConditionalExpression(consequent) || t.isLogicalExpression(consequent)) {
+			const consequentResult = wrapJsxExpression(t.jsxExpressionContainer(consequent), options, isMeaningful, mark);
+			if (t.isJSXExpressionContainer(consequentResult.node) && t.isExpression(consequentResult.node.expression)) {
+				expression.consequent = consequentResult.node.expression;
+				if (t.isParenthesizedExpression(expression.consequent)) expression.consequent.expression = consequentResult.node.expression;
+				else expression.consequent = consequentResult.node.expression;
+			}
+		} else if (t.isTemplateLiteral(consequent) && consequent.expressions.length > 0) {} else if (isStaticValue(consequent) && isMeaningful(consequent)) {
+			const wrapped = wrapExpressionWithT(consequent, options, false);
+			if (t.isParenthesizedExpression(expression.consequent)) expression.consequent.expression = wrapped;
+			else expression.consequent = wrapped;
+		}
+		if (t.isJSXElement(alternate) || t.isJSXFragment(alternate)) {
+			const result = handleJsxElement(alternate, options, isMeaningful);
+			if (t.isParenthesizedExpression(expression.alternate)) expression.alternate.expression = result.node;
+			else expression.alternate = result.node;
+		} else if (t.isConditionalExpression(alternate) || t.isLogicalExpression(alternate)) {
+			const alternateResult = wrapJsxExpression(t.jsxExpressionContainer(alternate), options, isMeaningful, mark);
+			if (t.isJSXExpressionContainer(alternateResult.node) && t.isExpression(alternateResult.node.expression)) {
+				expression.alternate = alternateResult.node.expression;
+				if (t.isParenthesizedExpression(expression.alternate)) expression.alternate.expression = alternateResult.node.expression;
+				else expression.alternate = alternateResult.node.expression;
+			}
+		} else if (t.isTemplateLiteral(alternate) && alternate.expressions.length > 0) {} else if (isStaticValue(alternate) && isMeaningful(alternate)) {
+			const wrapped = wrapExpressionWithT(alternate, options, false);
+			if (t.isParenthesizedExpression(expression.alternate)) expression.alternate.expression = wrapped;
+			else expression.alternate = wrapped;
+		}
+	} else if (t.isLogicalExpression(expression)) {
+		const left = t.isParenthesizedExpression(expression.left) ? expression.left.expression : expression.left;
+		const right = t.isParenthesizedExpression(expression.right) ? expression.right.expression : expression.right;
+		if (t.isJSXElement(left) || t.isJSXFragment(left)) {
+			const result = handleJsxElement(left, options, isMeaningful);
+			if (t.isParenthesizedExpression(expression.left)) expression.left.expression = result.node;
+			else expression.left = result.node;
+		} else if (t.isLogicalExpression(left) || t.isConditionalExpression(left)) {
+			const leftResult = wrapJsxExpression(t.jsxExpressionContainer(left), options, isMeaningful, mark);
+			if (t.isJSXExpressionContainer(leftResult.node) && t.isExpression(leftResult.node.expression)) if (t.isParenthesizedExpression(expression.left)) expression.left.expression = leftResult.node.expression;
+			else expression.left = leftResult.node.expression;
+		} else if (t.isTemplateLiteral(left) && left.expressions.length > 0) {} else if (isStaticValue(left) && isMeaningful(left) && expression.operator !== "&&") {
+			const wrapped = wrapExpressionWithT(left, options, false);
+			if (t.isParenthesizedExpression(expression.left)) expression.left.expression = wrapped;
+			else expression.left = wrapped;
+		}
+		if (t.isJSXElement(right) || t.isJSXFragment(right)) {
+			const result = handleJsxElement(right, options, isMeaningful);
+			if (t.isParenthesizedExpression(expression.right)) expression.right.expression = result.node;
+			else expression.right = result.node;
+		} else if (t.isLogicalExpression(right) || t.isConditionalExpression(right)) {
+			const rightResult = wrapJsxExpression(t.jsxExpressionContainer(right), options, isMeaningful, mark);
+			if (t.isJSXExpressionContainer(rightResult.node) && t.isExpression(rightResult.node.expression)) if (t.isParenthesizedExpression(expression.right)) expression.right.expression = rightResult.node.expression;
+			else expression.right = rightResult.node.expression;
+		} else if (t.isTemplateLiteral(right) && right.expressions.length > 0) {} else if (isStaticValue(right) && isMeaningful(right) && expression.operator !== "||") {
+			const wrapped = wrapExpressionWithT(right, options, false);
+			if (t.isParenthesizedExpression(expression.right)) expression.right.expression = wrapped;
+			else expression.right = wrapped;
+		}
+	}
+	if (!isStaticExpression(expression).isStatic) return {
+		node: wrapWithVar(node, options, mark),
+		hasMeaningfulContent: false,
+		wrappedInT: false
+	};
+	return {
+		node,
+		hasMeaningfulContent: false,
+		wrappedInT: false
+	};
 }
 /**
- * Recursively traverse a JSX element and wrap variables with a <Var> component
- * @param node - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export function wrapJsxElement(node, options, isMeaningful, mark) {
-    const TComponentName = options.TComponent || 'T';
-    const VarComponentName = options.VarComponent || 'Var';
-    // Handle both JSX Elements and Fragments
-    if (t.isJSXElement(node) || t.isJSXFragment(node)) {
-        // For elements, check if it's already a T or Var component
-        if (t.isJSXElement(node)) {
-            const name = node.openingElement.name;
-            if (t.isJSXIdentifier(name) &&
-                (name.name === TComponentName || name.name === VarComponentName)) {
-                return {
-                    node,
-                    hasMeaningfulContent: false,
-                    wrappedInT: name.name === TComponentName,
-                };
-            }
-        }
-        // Process children recursively (DFS postorder)
-        let hasMeaningfulContent = false;
-        let wrappedInT = false;
-        const processedChildren = node.children.map((child) => {
-            if (t.isJSXElement(child) || t.isJSXFragment(child)) {
-                const result = wrapJsxElement(child, options, isMeaningful, mark);
-                hasMeaningfulContent =
-                    hasMeaningfulContent || result.hasMeaningfulContent;
-                wrappedInT = wrappedInT || result.wrappedInT;
-                return result.node;
-            }
-            if (t.isJSXExpressionContainer(child)) {
-                const result = wrapJsxExpression(child, options, isMeaningful, mark);
-                wrappedInT = wrappedInT || result.wrappedInT;
-                hasMeaningfulContent =
-                    hasMeaningfulContent || result.hasMeaningfulContent;
-                // Expressions are never meaningful because they will either:
-                // 1. be sub-wrapped in a T (if they contain meaningful content)
-                // 2. be wrapped in a Var (if they are not marked as derivable)
-                return result.node;
-            }
-            const isMeaningfulVal = isMeaningful(child);
-            if (isMeaningfulVal) {
-                hasMeaningfulContent = true;
-            }
-            return child;
-        });
-        node.children = processedChildren;
-        return {
-            node,
-            hasMeaningfulContent: hasMeaningfulContent,
-            wrappedInT: wrappedInT,
-        };
-    }
-    // For any other node types, return as-is
-    return {
-        node,
-        hasMeaningfulContent: false,
-        wrappedInT: false,
-    };
+* Recursively traverse a JSX element and wrap variables with a <Var> component
+* @param node - The JSX element to wrap
+* @param options - Optional component names for T and Var
+* @param isMeaningful - A function to determine if a node is meaningful
+* @returns The wrapped JSX element
+*/
+function wrapJsxElement(node, options, isMeaningful, mark) {
+	const TComponentName = options.TComponent || "T";
+	const VarComponentName = options.VarComponent || "Var";
+	if (t.isJSXElement(node) || t.isJSXFragment(node)) {
+		if (t.isJSXElement(node)) {
+			const name = node.openingElement.name;
+			if (t.isJSXIdentifier(name) && (name.name === TComponentName || name.name === VarComponentName)) return {
+				node,
+				hasMeaningfulContent: false,
+				wrappedInT: name.name === TComponentName
+			};
+		}
+		let hasMeaningfulContent = false;
+		let wrappedInT = false;
+		node.children = node.children.map((child) => {
+			if (t.isJSXElement(child) || t.isJSXFragment(child)) {
+				const result = wrapJsxElement(child, options, isMeaningful, mark);
+				hasMeaningfulContent = hasMeaningfulContent || result.hasMeaningfulContent;
+				wrappedInT = wrappedInT || result.wrappedInT;
+				return result.node;
+			}
+			if (t.isJSXExpressionContainer(child)) {
+				const result = wrapJsxExpression(child, options, isMeaningful, mark);
+				wrappedInT = wrappedInT || result.wrappedInT;
+				hasMeaningfulContent = hasMeaningfulContent || result.hasMeaningfulContent;
+				return result.node;
+			}
+			if (isMeaningful(child)) hasMeaningfulContent = true;
+			return child;
+		});
+		return {
+			node,
+			hasMeaningfulContent,
+			wrappedInT
+		};
+	}
+	return {
+		node,
+		hasMeaningfulContent: false,
+		wrappedInT: false
+	};
 }
 /**
- * Wraps a JSX element with a <T> component and unique id
- * @param rootNode - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export function handleJsxElement(rootNode, options, isMeaningful) {
-    const result = wrapJsxElement(rootNode, options, isMeaningful, true);
-    // Only wrap with T at the root level if there's meaningful content
-    if (result.hasMeaningfulContent) {
-        const output = wrapJsxElement(result.node, options, isMeaningful, false);
-        const node = wrapWithT(output.node, options, false);
-        return {
-            node,
-            hasMeaningfulContent: true,
-            wrappedInT: true,
-        };
-    }
-    return {
-        node: result.node,
-        hasMeaningfulContent: false,
-        wrappedInT: result.wrappedInT,
-    };
+* Wraps a JSX element with a <T> component and unique id
+* @param rootNode - The JSX element to wrap
+* @param options - Optional component names for T and Var
+* @param isMeaningful - A function to determine if a node is meaningful
+* @returns The wrapped JSX element
+*/
+function handleJsxElement(rootNode, options, isMeaningful) {
+	const result = wrapJsxElement(rootNode, options, isMeaningful, true);
+	if (result.hasMeaningfulContent) return {
+		node: wrapWithT(wrapJsxElement(result.node, options, isMeaningful, false).node, options, false),
+		hasMeaningfulContent: true,
+		wrappedInT: true
+	};
+	return {
+		node: result.node,
+		hasMeaningfulContent: false,
+		wrappedInT: result.wrappedInT
+	};
 }
 function wrapWithT(node, options, mark) {
-    if (mark) {
-        return node;
-    }
-    const TComponentName = options.TComponent || 'T';
-    const uniqueId = `${options.idPrefix}.${options.idCount}`;
-    options.modified = true;
-    options.idCount++;
-    if (!options.usedImports.includes(TComponentName)) {
-        options.usedImports.push(TComponentName);
-    }
-    if (options.createIds) {
-        return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [t.jsxAttribute(t.jsxIdentifier('id'), t.stringLiteral(uniqueId))], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [node], false);
-    }
-    return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [node], false);
+	if (mark) return node;
+	const TComponentName = options.TComponent || "T";
+	const uniqueId = `${options.idPrefix}.${options.idCount}`;
+	options.modified = true;
+	options.idCount++;
+	if (!options.usedImports.includes(TComponentName)) options.usedImports.push(TComponentName);
+	if (options.createIds) return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [t.jsxAttribute(t.jsxIdentifier("id"), t.stringLiteral(uniqueId))], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [node], false);
+	return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [node], false);
 }
 function wrapExpressionWithT(node, options, mark) {
-    if (mark) {
-        return node;
-    }
-    const TComponentName = options.TComponent || 'T';
-    const uniqueId = `${options.idPrefix}.${options.idCount}`;
-    options.modified = true;
-    options.idCount++;
-    if (!options.usedImports.includes(TComponentName)) {
-        options.usedImports.push(TComponentName);
-    }
-    if (options.createIds) {
-        return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [t.jsxAttribute(t.jsxIdentifier('id'), t.stringLiteral(uniqueId))], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [t.jsxExpressionContainer(node)], false);
-    }
-    return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [t.jsxExpressionContainer(node)], false);
+	if (mark) return node;
+	const TComponentName = options.TComponent || "T";
+	const uniqueId = `${options.idPrefix}.${options.idCount}`;
+	options.modified = true;
+	options.idCount++;
+	if (!options.usedImports.includes(TComponentName)) options.usedImports.push(TComponentName);
+	if (options.createIds) return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [t.jsxAttribute(t.jsxIdentifier("id"), t.stringLiteral(uniqueId))], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [t.jsxExpressionContainer(node)], false);
+	return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [t.jsxExpressionContainer(node)], false);
 }
 function wrapWithVar(node, options, mark) {
-    if (mark) {
-        return node;
-    }
-    const VarComponentName = options.VarComponent || 'Var';
-    options.modified = true;
-    if (!options.usedImports.includes(VarComponentName)) {
-        options.usedImports.push(VarComponentName);
-    }
-    return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(VarComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(VarComponentName)), [node], false);
+	if (mark) return node;
+	const VarComponentName = options.VarComponent || "Var";
+	options.modified = true;
+	if (!options.usedImports.includes(VarComponentName)) options.usedImports.push(VarComponentName);
+	return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(VarComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(VarComponentName)), [node], false);
 }
+//#endregion
+export { handleJsxElement, wrapJsxElement };
+
+//# sourceMappingURL=wrapJsx.js.map