gtx-cli 2.3.5 → 2.3.6-alpha.1

package/dist/next/parse/handleInitGT.js

@@ -1,208 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

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

package/dist/react/config/createESBuildConfig.js

@@ -1,119 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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;