gtx-cli 2.3.6-alpha.2 → 2.3.6

package/dist/next/parse/handleInitGT.js

@@ -0,0 +1,208 @@
+import fs from 'node:fs';
+import { parse } from '@babel/parser';
+import generateModule from '@babel/generator';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+const generate = generateModule.default || generateModule;
+import * as t from '@babel/types';
+import { logError } from '../../console/logging.js';
+export async function handleInitGT(filepath, errors, warnings, filesUpdated, packageJson, tsconfigJson) {
+    const code = await fs.promises.readFile(filepath, 'utf8');
+    let ast;
+    try {
+        ast = parse(code, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript'],
+            tokens: true,
+            createParenthesizedExpressions: true,
+        });
+        // Analyze the actual file content to determine module system
+        let hasES6Imports = false;
+        let hasCommonJSRequire = false;
+        traverse(ast, {
+            ImportDeclaration() {
+                hasES6Imports = true;
+            },
+            CallExpression(path) {
+                if (t.isIdentifier(path.node.callee, { name: 'require' })) {
+                    hasCommonJSRequire = true;
+                }
+            },
+        });
+        // Determine if we need CommonJS based on actual file content and fallback to config-based logic
+        let needsCJS = false;
+        if (hasES6Imports && !hasCommonJSRequire) {
+            // File uses ES6 imports, so we should use ES6 imports
+            needsCJS = false;
+        }
+        else if (hasCommonJSRequire && !hasES6Imports) {
+            // File uses CommonJS require, so we should use CommonJS require
+            needsCJS = true;
+        }
+        else if (hasES6Imports && hasCommonJSRequire) {
+            // Mixed usage - this is unusual but we'll default to ES6 imports
+            warnings.push(`Mixed ES6 imports and CommonJS require detected in ${filepath}. Defaulting to ES6 imports.`);
+            needsCJS = false;
+        }
+        else {
+            // No imports/requires found, fall back to configuration-based logic
+            if (filepath.endsWith('.ts') || filepath.endsWith('.tsx')) {
+                // For TypeScript files, check tsconfig.json compilerOptions.module
+                const moduleSetting = tsconfigJson?.compilerOptions?.module;
+                if (moduleSetting === 'commonjs' || moduleSetting === 'node') {
+                    needsCJS = true;
+                }
+                else if (moduleSetting === 'esnext' ||
+                    moduleSetting === 'es2022' ||
+                    moduleSetting === 'es2020' ||
+                    moduleSetting === 'es2015' ||
+                    moduleSetting === 'es6' ||
+                    moduleSetting === 'node16' ||
+                    moduleSetting === 'nodenext') {
+                    needsCJS = false;
+                }
+                else {
+                    // Default to ESM for TypeScript files if no module setting is specified
+                    needsCJS = false;
+                }
+            }
+            else if (filepath.endsWith('.js')) {
+                // For JavaScript files, check package.json type
+                // If package.json has "type": "module", .js files are treated as ES modules
+                needsCJS = packageJson?.type !== 'module';
+            }
+            else {
+                // For other file extensions, default to ESM
+                needsCJS = false;
+            }
+        }
+        // Check if withGTConfig or initGT is already imported/required
+        let hasGTConfig = false;
+        let hasInitGT = false;
+        traverse(ast, {
+            ImportDeclaration(path) {
+                if (path.node.source.value === 'gt-next/config') {
+                    path.node.specifiers.forEach((spec) => {
+                        if (t.isImportSpecifier(spec)) {
+                            if (spec.local.name === 'withGTConfig')
+                                hasGTConfig = true;
+                            if (spec.local.name === 'initGT')
+                                hasInitGT = true;
+                        }
+                    });
+                }
+            },
+            VariableDeclaration(path) {
+                path.node.declarations.forEach((dec) => {
+                    if (t.isVariableDeclarator(dec)) {
+                        // Handle destructuring: const { withGTConfig } = require('gt-next/config')
+                        if (t.isCallExpression(dec.init) &&
+                            t.isIdentifier(dec.init.callee, { name: 'require' }) &&
+                            t.isStringLiteral(dec.init.arguments[0], {
+                                value: 'gt-next/config',
+                            })) {
+                            // Handle simple assignment: const withGTConfig = require(...)
+                            if (t.isIdentifier(dec.id, { name: 'withGTConfig' }))
+                                hasGTConfig = true;
+                            if (t.isIdentifier(dec.id, { name: 'initGT' }))
+                                hasInitGT = true;
+                            // Handle destructuring: const { withGTConfig } = require(...)
+                            if (t.isObjectPattern(dec.id)) {
+                                dec.id.properties.forEach((prop) => {
+                                    if (t.isObjectProperty(prop) &&
+                                        t.isIdentifier(prop.key) &&
+                                        t.isIdentifier(prop.value)) {
+                                        if (prop.key.name === 'withGTConfig')
+                                            hasGTConfig = true;
+                                        if (prop.key.name === 'initGT')
+                                            hasInitGT = true;
+                                    }
+                                });
+                            }
+                        }
+                        // Handle member access: const withGTConfig = require('gt-next/config').withGTConfig
+                        else if (t.isMemberExpression(dec.init) &&
+                            t.isCallExpression(dec.init.object) &&
+                            t.isIdentifier(dec.init.object.callee, { name: 'require' }) &&
+                            t.isStringLiteral(dec.init.object.arguments[0], {
+                                value: 'gt-next/config',
+                            })) {
+                            if (t.isIdentifier(dec.id, { name: 'withGTConfig' }) &&
+                                t.isIdentifier(dec.init.property, { name: 'withGTConfig' })) {
+                                hasGTConfig = true;
+                            }
+                            if (t.isIdentifier(dec.id, { name: 'initGT' }) &&
+                                t.isIdentifier(dec.init.property, { name: 'initGT' })) {
+                                hasInitGT = true;
+                            }
+                        }
+                    }
+                });
+            },
+        });
+        // Return early if either withGTConfig or initGT is already present
+        if (hasGTConfig || hasInitGT) {
+            return;
+        }
+        ast.program.body.unshift(needsCJS
+            ? t.variableDeclaration('const', [
+                t.variableDeclarator(t.identifier('withGTConfig'), t.memberExpression(t.callExpression(t.identifier('require'), [
+                    t.stringLiteral('gt-next/config'),
+                ]), t.identifier('withGTConfig'))),
+            ])
+            : t.importDeclaration([
+                t.importSpecifier(t.identifier('withGTConfig'), t.identifier('withGTConfig')),
+            ], t.stringLiteral('gt-next/config')));
+        // Find and transform the default export
+        traverse(ast, {
+            ExportDefaultDeclaration(path) {
+                const oldExport = path.node.declaration;
+                let exportExpression;
+                if (t.isFunctionDeclaration(oldExport)) {
+                    exportExpression = t.functionExpression(oldExport.id, oldExport.params, oldExport.body, oldExport.generator, oldExport.async);
+                }
+                else if (t.isClassDeclaration(oldExport)) {
+                    exportExpression = t.classExpression(oldExport.id, oldExport.superClass, oldExport.body, oldExport.decorators);
+                }
+                else if (t.isTSDeclareFunction(oldExport)) {
+                    // For TypeScript declare functions, create an empty function expression
+                    // since declare functions don't have a runtime implementation
+                    warnings.push(`Found TypeScript declare function in ${filepath}. Converting to empty function.`);
+                    exportExpression = t.functionExpression(oldExport.id, oldExport.params, t.blockStatement([]), false, false);
+                }
+                else {
+                    exportExpression = oldExport;
+                }
+                // Validate that we have a valid Next.js config export
+                if (!t.isObjectExpression(exportExpression) &&
+                    !t.isFunctionExpression(exportExpression) &&
+                    !t.isArrowFunctionExpression(exportExpression)) {
+                    warnings.push(`Unexpected export type in ${filepath}. Next.js config should export an object or a function returning an object.`);
+                }
+                path.node.declaration = t.callExpression(t.identifier('withGTConfig'), [
+                    exportExpression,
+                    t.objectExpression([]),
+                ]);
+            },
+        });
+        // Generate the modified code
+        const output = generate(ast, {
+            retainLines: true,
+            retainFunctionParens: true,
+            comments: true,
+            compact: 'auto',
+        }, code);
+        // Post-process the output to fix import spacing
+        let processedCode = output.code;
+        // Add newline after the comment only
+        processedCode = processedCode.replace(/((?:import\s*{\s*withGTConfig\s*}\s*from|const\s*{\s*withGTConfig\s*}\s*=\s*require)\s*['"]gt-next\/config['"];?)/, '$1\n');
+        // Write the modified code back to the file
+        await fs.promises.writeFile(filepath, processedCode);
+        filesUpdated.push(filepath);
+    }
+    catch (error) {
+        logError(`Error parsing file ${filepath}: ${error}`);
+        errors.push(`Failed to parse ${filepath}: ${error}`);
+    }
+}

package/dist/next/parse/wrapContent.d.ts

@@ -0,0 +1,11 @@
+import { WrapOptions } from '../../types/index.js';
+/**
+ * Wraps all JSX elements in the src directory with a <T> tag, with unique ids.
+ * - Ignores pure strings
+ *
+ * @param options - The options object
+ * @returns An object containing the updates and errors
+ */
+export declare function wrapContentNext(options: WrapOptions, pkg: 'gt-next', errors: string[], warnings: string[]): Promise<{
+    filesUpdated: string[];
+}>;

package/dist/next/parse/wrapContent.js

@@ -0,0 +1,163 @@
+import fs from 'node:fs';
+import * as t from '@babel/types';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import generateModule from '@babel/generator';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+const generate = generateModule.default || generateModule;
+import { isMeaningful } from '../../react/jsx/evaluateJsx.js';
+import { handleJsxElement } from '../../react/jsx/wrapJsx.js';
+import { getRelativePath } from '../../fs/findFilepath.js';
+import { isHtmlElement, isBodyElement, hasGTProviderChild, addDynamicLangAttribute, makeParentFunctionAsync, } from '../jsx/utils.js';
+import { generateImportMap, createImports, } from '../../react/jsx/utils/parseAst.js';
+import { matchFiles } from '../../fs/matchFiles.js';
+import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
+const IMPORT_MAP = {
+    T: { name: 'T', source: 'gt-next' },
+    Var: { name: 'Var', source: 'gt-next' },
+    GTT: { name: 'T', source: 'gt-next' },
+    GTVar: { name: 'Var', source: 'gt-next' },
+    GTProvider: { name: 'GTProvider', source: 'gt-next' },
+    getLocale: { name: 'getLocale', source: 'gt-next/server' },
+};
+/**
+ * Wraps all JSX elements in the src directory with a <T> tag, with unique ids.
+ * - Ignores pure strings
+ *
+ * @param options - The options object
+ * @returns An object containing the updates and errors
+ */
+export async function wrapContentNext(options, pkg, errors, warnings) {
+    const files = matchFiles(process.cwd(), options.src || DEFAULT_SRC_PATTERNS);
+    const filesUpdated = [];
+    for (const file of files) {
+        const code = await fs.promises.readFile(file, 'utf8');
+        // Create relative path from src directory and remove extension
+        const relativePath = getRelativePath(file, process.cwd());
+        let ast;
+        try {
+            ast = parse(code, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript'],
+                tokens: true,
+                createParenthesizedExpressions: true,
+            });
+        }
+        catch (error) {
+            errors.push(`Error: Failed to parse ${file}: ${error}`);
+            continue;
+        }
+        let modified = false;
+        const usedImports = [];
+        const { importAlias, initialImports } = generateImportMap(ast, pkg);
+        // If the file already has a T import, skip processing it
+        if (initialImports.includes(IMPORT_MAP.T.name)) {
+            continue;
+        }
+        let globalId = 0;
+        traverse(ast, {
+            JSXElement(path) {
+                if (pkg === 'gt-next' &&
+                    options.addGTProvider &&
+                    isHtmlElement(path.node.openingElement)) {
+                    // Find the body element recursively in the HTML tree
+                    const findBodyElement = (children) => {
+                        for (const child of children) {
+                            if (t.isJSXElement(child) &&
+                                isBodyElement(child.openingElement)) {
+                                return child;
+                            }
+                            if (t.isJSXElement(child)) {
+                                const bodyInChild = findBodyElement(child.children);
+                                if (bodyInChild)
+                                    return bodyInChild;
+                            }
+                        }
+                        return null;
+                    };
+                    const bodyElement = findBodyElement(path.node.children);
+                    if (!bodyElement) {
+                        warnings.push(`File ${file} has a <html> tag without a <body> tag. Skipping GTProvider insertion.`);
+                        return;
+                    }
+                    // Skip if body already has GTProvider
+                    if (hasGTProviderChild(bodyElement)) {
+                        return;
+                    }
+                    // Handle lang attribute for html tag
+                    const langAttr = path.node.openingElement.attributes.find((attr) => t.isJSXAttribute(attr) &&
+                        t.isJSXIdentifier(attr.name) &&
+                        t.isStringLiteral(attr.value) &&
+                        attr.name.name === 'lang');
+                    if (langAttr) {
+                        makeParentFunctionAsync(path);
+                        addDynamicLangAttribute(path.node.openingElement);
+                        usedImports.push('getLocale');
+                    }
+                    // Wrap body children with GTProvider
+                    const bodyChildren = bodyElement.children;
+                    const gtProviderElement = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier('GTProvider'), [], false), t.jsxClosingElement(t.jsxIdentifier('GTProvider')), bodyChildren, false);
+                    bodyElement.children = [gtProviderElement];
+                    usedImports.push('GTProvider');
+                    modified = true;
+                    path.skip();
+                    return;
+                }
+                // If skip wrapping Ts, skip processing this node
+                if (options.skipTs) {
+                    return;
+                }
+                // Check if this JSX element has any JSX element ancestors
+                if (t.isJSXElement(path.parentPath?.node) ||
+                    t.isJSXExpressionContainer(path.parentPath?.node)) {
+                    // If we found a JSX parent, skip processing this node
+                    return;
+                }
+                // At this point, we're only processing top-level JSX elements
+                const opts = {
+                    ...importAlias,
+                    idPrefix: relativePath,
+                    idCount: globalId,
+                    usedImports,
+                    modified: false,
+                    createIds: !options.disableIds,
+                    warnings,
+                    file,
+                };
+                const wrapped = handleJsxElement(path.node, opts, isMeaningful);
+                path.replaceWith(wrapped.node);
+                // Update global counters
+                modified = modified || opts.modified;
+                globalId = opts.idCount;
+            },
+        });
+        if (!modified)
+            continue;
+        const needsImport = usedImports.filter((imp) => !initialImports.includes(imp));
+        if (needsImport.length > 0) {
+            createImports(ast, needsImport, IMPORT_MAP);
+        }
+        try {
+            const output = generate(ast, {
+                retainLines: true,
+                retainFunctionParens: true,
+                comments: true,
+                compact: 'auto',
+            }, code);
+            // Post-process the output to fix import spacing
+            let processedCode = output.code;
+            if (needsImport.length > 0) {
+                // Add newline after the comment only
+                processedCode = processedCode.replace(/((?:import\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*from|const\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*=\s*require)\s*['"]gt-(?:next|react)(?:\/server)?['"];?)/, '\n$1\n');
+            }
+            // Write the modified code back to the file
+            await fs.promises.writeFile(file, processedCode);
+            filesUpdated.push(file);
+        }
+        catch (error) {
+            errors.push(`Error: Failed to write ${file}: ${error}`);
+        }
+    }
+    return { filesUpdated };
+}

package/dist/react/config/createESBuildConfig.d.ts

@@ -0,0 +1,2 @@
+import esbuild from 'esbuild';
+export default function createESBuildConfig(config?: Record<string, any>): esbuild.BuildOptions;

package/dist/react/config/createESBuildConfig.js

@@ -0,0 +1,119 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { displayResolvedPaths } from '../../console/logging.js';
+export default function createESBuildConfig(config = {}) {
+    const esbuildOptions = {
+        bundle: true,
+        format: 'cjs',
+        platform: 'node',
+        target: 'es2021',
+        loader: {
+            '.js': 'jsx',
+            '.ts': 'ts',
+            '.css': 'css', // Add CSS loader
+        },
+        sourcemap: 'inline',
+        external: ['server-only'],
+        define: {
+            React: 'global.React',
+        },
+        plugins: [],
+    };
+    // Add the custom plugin to handle 'server-only' imports
+    esbuildOptions.plugins.push({
+        name: 'ignore-server-only',
+        setup(build) {
+            build.onResolve({ filter: /^server-only$/ }, () => {
+                return {
+                    path: 'server-only',
+                    namespace: 'ignore-server-only',
+                };
+            });
+            build.onLoad({ filter: /^server-only$/, namespace: 'ignore-server-only' }, () => {
+                return {
+                    contents: 'module.exports = {};',
+                    loader: 'js',
+                };
+            });
+        },
+    });
+    // Add a plugin to handle CSS imports
+    esbuildOptions.plugins.push({
+        name: 'css-module',
+        setup(build) {
+            build.onResolve({ filter: /\.css$/ }, (args) => {
+                return {
+                    path: path.resolve(args.resolveDir, args.path),
+                    namespace: 'css-module',
+                };
+            });
+            build.onLoad({ filter: /\.css$/, namespace: 'css-module' }, async (args) => {
+                const css = await fs.promises.readFile(args.path, 'utf8');
+                const contents = `
+                    const style = document.createElement('style');
+                    style.textContent = ${JSON.stringify(css)};
+                    document.head.appendChild(style);
+                `;
+                return { contents, loader: 'js' };
+            });
+        },
+    });
+    if (config.compilerOptions) {
+        if (config.compilerOptions.paths) {
+            const aliases = {};
+            const resolvedPaths = [];
+            for (const [key, value] of Object.entries(config.compilerOptions.paths)) {
+                if (Array.isArray(value) && typeof value[0] === 'string') {
+                    const resolvedPath = path.resolve(process.cwd(), value[0].replace('/*', ''));
+                    aliases[key.replace('/*', '')] = resolvedPath;
+                    resolvedPaths.push([key, resolvedPath]);
+                }
+            }
+            if (resolvedPaths.length) {
+                displayResolvedPaths(resolvedPaths);
+            }
+            esbuildOptions.plugins = esbuildOptions.plugins || [];
+            esbuildOptions.plugins.push({
+                name: 'alias',
+                setup(build) {
+                    build.onResolve({ filter: /.*/ }, (args) => {
+                        for (const [aliasKey, aliasPath] of Object.entries(aliases)) {
+                            if (args.path.startsWith(`${aliasKey}/`)) {
+                                const resolvedPath = path.resolve(aliasPath, args.path.slice(aliasKey.length + 1));
+                                const extensions = ['.js', '.ts', '.css']; // Add .css to extensions
+                                function resolveWithExtensions(basePath) {
+                                    for (const ext of extensions) {
+                                        const fullPath = `${basePath}${ext}`;
+                                        try {
+                                            const realPath = fs.realpathSync(fullPath);
+                                            return realPath;
+                                        }
+                                        catch (_) {
+                                            continue;
+                                        }
+                                    }
+                                    return null;
+                                }
+                                try {
+                                    const realPath = fs.realpathSync(resolvedPath);
+                                    return { path: realPath };
+                                }
+                                catch (err) {
+                                    const hasExtension = extensions.some((ext) => resolvedPath.endsWith(ext));
+                                    if (!hasExtension) {
+                                        const resolvedWithExt = resolveWithExtensions(resolvedPath);
+                                        if (resolvedWithExt) {
+                                            return { path: resolvedWithExt };
+                                        }
+                                    }
+                                    throw new Error(`Unable to resolve path: ${resolvedPath}`);
+                                }
+                            }
+                        }
+                    });
+                },
+            });
+        }
+    }
+    return esbuildOptions;
+}

package/dist/react/data-_gt/addGTIdentifierToSyntaxTree.d.ts

@@ -0,0 +1,8 @@
+import { JsxChildren } from 'generaltranslation/types';
+/**
+ * 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;

package/dist/react/data-_gt/addGTIdentifierToSyntaxTree.js

@@ -0,0 +1,111 @@
+import { HTML_CONTENT_PROPS, } from 'generaltranslation/types';
+import { defaultVariableNames, getVariableName, minifyVariableType, } from '../utils/getVariableName.js';
+import { isAcceptedPluralForm } from 'generaltranslation/internal';
+/**
+ * Construct the data-_gt prop
+ * @param type - The type of the element
+ * @param props - The props of the element
+ * @param id - The id of the element
+ * @returns The data-_gt prop
+ */
+function constructGTProp(type, props, id) {
+    // Add translatable HTML content props
+    const generaltranslation = Object.entries(HTML_CONTENT_PROPS).reduce((acc, [minifiedName, fullName]) => {
+        if (props[fullName]) {
+            acc[minifiedName] = props[fullName];
+        }
+        return acc;
+    }, {});
+    // Plural
+    if (type === 'Plural') {
+        const pluralBranches = Object.entries(props).reduce((acc, [branchName, branch]) => {
+            if (isAcceptedPluralForm(branchName)) {
+                acc[branchName] = addGTIdentifierToSyntaxTree(branch, id);
+            }
+            return acc;
+        }, {});
+        // Add plural branches to the generaltranslation
+        if (Object.keys(pluralBranches).length) {
+            generaltranslation.t = 'p';
+            generaltranslation.b = pluralBranches;
+        }
+        // Branch
+    }
+    else if (type === 'Branch') {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+        const { children, branch, ...branches } = props;
+        const resultBranches = Object.entries(branches).reduce((acc, [branchName, branch]) => {
+            acc[branchName] = addGTIdentifierToSyntaxTree(branch, id);
+            return acc;
+        }, {});
+        // Add branches to the generaltranslation
+        if (Object.keys(resultBranches).length) {
+            generaltranslation.t = 'b';
+            generaltranslation.b = resultBranches;
+        }
+    }
+    return Object.keys(generaltranslation).length
+        ? generaltranslation
+        : undefined;
+}
+/**
+ * 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, startingIndex = 0) {
+    // Object to keep track of the current index for GT IDs
+    const indexObject = { index: startingIndex };
+    /**
+     * Handle a single child
+     * @param child - The child to handle
+     * @returns The handled child
+     */
+    const handleSingleChild = (child) => {
+        // Handle JSX elements
+        if (child && typeof child === 'object') {
+            let { type } = child;
+            const { props } = child;
+            indexObject.index += 1;
+            // Handle fragments
+            if (type === 'React.Fragment') {
+                type = '';
+            }
+            // Variables
+            if (Object.keys(defaultVariableNames).includes(type)) {
+                const variableType = minifyVariableType(type);
+                const variableName = getVariableName(props, type, indexObject.index);
+                return {
+                    i: indexObject.index,
+                    k: variableName,
+                    v: variableType,
+                };
+            }
+            // Construct the data-_gt prop
+            const generaltranslation = constructGTProp(type, props, indexObject.index);
+            // Return the result
+            return {
+                t: type || `C${indexObject.index}`,
+                i: indexObject.index,
+                c: handleChildren(props.children),
+                ...(generaltranslation && { d: generaltranslation }),
+            };
+        }
+        if (typeof child === 'number') {
+            return child.toString();
+        }
+        return child;
+    };
+    /**
+     * Handle children
+     * @param children - The children to handle
+     * @returns The handled children
+     */
+    const handleChildren = (children) => {
+        return Array.isArray(children)
+            ? children.map(handleSingleChild)
+            : handleSingleChild(children);
+    };
+    return handleChildren(tree);
+}

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

@@ -0,0 +1,17 @@
+import * as t from '@babel/types';
+/**
+ * Checks if a node is meaningful. Does not recurse into children.
+ * @param node - The node to check
+ * @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): {
+    isStatic: boolean;
+    value?: string;
+};
+export declare function isStaticValue(expr: t.Expression | t.JSXEmptyExpression): boolean;