gtx-cli 2.3.6-alpha.2 → 2.3.6-alpha.3

package/dist/react/jsx/evaluateJsx.js

@@ -0,0 +1,85 @@
+import * as t from '@babel/types';
+import generateModule from '@babel/generator';
+// Handle CommonJS/ESM interop
+const generate = generateModule.default || generateModule;
+const MEANINGFUL_REGEX = /[\p{L}\p{N}]/u;
+/**
+ * Checks if a node is meaningful. Does not recurse into children.
+ * @param node - The node to check
+ * @returns Whether the node is meaningful
+ */
+export function isMeaningful(node) {
+    if (t.isStringLiteral(node) || t.isJSXText(node)) {
+        return MEANINGFUL_REGEX.test(node.value);
+    }
+    // Handle template literals without expressions
+    if (t.isTemplateLiteral(node) && node.expressions.length === 0) {
+        return MEANINGFUL_REGEX.test(node.quasis[0].value.raw);
+    }
+    if (t.isJSXExpressionContainer(node)) {
+        const value = isStaticExpression(node.expression);
+        if (value.isStatic && value.value) {
+            return MEANINGFUL_REGEX.test(value.value);
+        }
+    }
+    if (t.isBinaryExpression(node)) {
+        if (node.operator === '+') {
+            return isMeaningful(node.left) || isMeaningful(node.right);
+        }
+    }
+    return false;
+}
+/**
+ * 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 function isStaticExpression(expr) {
+    // Handle empty expressions
+    if (t.isJSXEmptyExpression(expr)) {
+        return { isStatic: true, value: '' };
+    }
+    // Handle direct string literals
+    if (t.isStringLiteral(expr)) {
+        return { isStatic: true, value: expr.value };
+    }
+    // Handle template literals without expressions
+    if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) {
+        return { isStatic: true, value: expr.quasis[0].value.raw };
+    }
+    // Binary expressions are not static
+    if (t.isBinaryExpression(expr)) {
+        // Not a static expression
+        return { isStatic: false };
+    }
+    // Handle parenthesized expressions
+    if (t.isParenthesizedExpression(expr)) {
+        return isStaticExpression(expr.expression);
+    }
+    // Handle numeric literals by converting them to strings
+    if (t.isNumericLiteral(expr)) {
+        return { isStatic: true, value: String(expr.value) };
+    }
+    // Handle boolean literals by converting them to strings
+    if (t.isBooleanLiteral(expr)) {
+        return { isStatic: true, value: String(expr.value) };
+    }
+    // Handle null literal
+    if (t.isNullLiteral(expr)) {
+        return { isStatic: true, value: 'null' };
+    }
+    // Not a static expression
+    return { isStatic: false };
+}
+export function isStaticValue(expr) {
+    if (t.isStringLiteral(expr)) {
+        return true;
+    }
+    if (t.isNumericLiteral(expr)) {
+        return true;
+    }
+    if (t.isTemplateLiteral(expr)) {
+        return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,7 @@
+export declare function trimJsxStringChild(child: string, index: number, childrenTypes: ('expression' | 'text' | 'element')[]): string;
+/**
+ * Handles whitespace in children of a JSX element.
+ * @param currentTree - The current tree to handle
+ * @returns The processed tree with whitespace handled
+ */
+export declare const handleChildrenWhitespace: (currentTree: any) => any;

package/dist/react/jsx/trimJsxStringChildren.js

@@ -0,0 +1,95 @@
+import { isAcceptedPluralForm } from 'generaltranslation/internal';
+export function trimJsxStringChild(child, index, childrenTypes) {
+    // Normalize line endings to \n for consistency across platforms
+    let result = child.replace(/\r\n|\r/g, '\n');
+    // Collapse multiple spaces/tabs into a single space
+    result = result.replace(/[\t ]+/g, ' ');
+    let newResult = '';
+    let newline = false;
+    for (const char of result) {
+        if (char === '\n') {
+            if (newResult.trim())
+                newResult += ' ';
+            else
+                newResult = '';
+            newline = true;
+            continue;
+        }
+        if (!newline) {
+            newResult += char;
+            continue;
+        }
+        if (char.trim() === '')
+            continue;
+        newResult += char;
+        newline = false;
+    }
+    if (newline)
+        newResult = newResult.trimEnd();
+    result = newResult;
+    // Collapse multiple spaces/tabs into a single space
+    result = result.replace(/[\t ]+/g, ' ');
+    return result;
+}
+/**
+ * Handles whitespace in children of a JSX element.
+ * @param currentTree - The current tree to handle
+ * @returns The processed tree with whitespace handled
+ */
+export const handleChildrenWhitespace = (currentTree) => {
+    if (Array.isArray(currentTree)) {
+        const childrenTypes = currentTree.map((child) => {
+            if (typeof child === 'string')
+                return 'text';
+            if (typeof child === 'object' && 'expression' in child)
+                return 'expression';
+            return 'element';
+        });
+        const newChildren = [];
+        currentTree.forEach((child, index) => {
+            if (childrenTypes[index] === 'text') {
+                const string = trimJsxStringChild(child, index, childrenTypes);
+                if (string)
+                    newChildren.push(string);
+            }
+            else if (childrenTypes[index] === 'expression') {
+                newChildren.push(child.result);
+            }
+            else {
+                newChildren.push(handleChildrenWhitespace(child));
+            }
+        });
+        return newChildren.length === 1 ? newChildren[0] : newChildren;
+    }
+    else if (currentTree?.props) {
+        // Process all props recursively
+        const elementIsPlural = currentTree.type === 'Plural';
+        const elementIsBranch = currentTree.type === 'Branch';
+        const processedProps = Object.fromEntries(Object.entries(currentTree.props).map(([key, value]) => {
+            let shouldProcess = false;
+            if (key === 'children')
+                shouldProcess = true;
+            if (elementIsPlural && isAcceptedPluralForm(key))
+                shouldProcess = true;
+            if (elementIsBranch && key !== 'branch')
+                shouldProcess = true;
+            // Add your validation logic here
+            if (shouldProcess) {
+                return [key, handleChildrenWhitespace(value)];
+            }
+            return [key, value];
+        }));
+        return {
+            ...currentTree,
+            props: processedProps,
+        };
+    }
+    else if (typeof currentTree === 'object' &&
+        'expression' in currentTree === true) {
+        return currentTree.result;
+    }
+    else if (typeof currentTree === 'string') {
+        return trimJsxStringChild(currentTree, 0, ['text']);
+    }
+    return currentTree;
+};

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

@@ -0,0 +1,10 @@
+export declare const MSG_TRANSLATION_HOOK = "msg";
+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 GT_TRANSLATION_FUNCS: string[];
+export declare const VARIABLE_COMPONENTS: string[];
+export declare const GT_ATTRIBUTES_WITH_SUGAR: string[];
+export declare const GT_ATTRIBUTES: string[];
+export declare function mapAttributeName(attrName: string): string;

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

@@ -0,0 +1,31 @@
+export const MSG_TRANSLATION_HOOK = 'msg';
+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';
+// GT translation functions
+export const GT_TRANSLATION_FUNCS = [
+    INLINE_TRANSLATION_HOOK,
+    INLINE_TRANSLATION_HOOK_ASYNC,
+    INLINE_MESSAGE_HOOK,
+    INLINE_MESSAGE_HOOK_ASYNC,
+    MSG_TRANSLATION_HOOK,
+    'T',
+    'Var',
+    'DateTime',
+    'Currency',
+    'Num',
+    'Branch',
+    'Plural',
+];
+// Valid variable components
+export const VARIABLE_COMPONENTS = ['Var', 'DateTime', 'Currency', 'Num'];
+export const GT_ATTRIBUTES_WITH_SUGAR = ['$id', '$context'];
+export const GT_ATTRIBUTES = ['id', 'context', ...GT_ATTRIBUTES_WITH_SUGAR];
+export function mapAttributeName(attrName) {
+    if (attrName === '$id')
+        return 'id';
+    if (attrName === '$context')
+        return 'context';
+    return attrName;
+}

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

@@ -0,0 +1,30 @@
+import * as t from '@babel/types';
+import { ParseResult } from '@babel/parser';
+import { ImportDeclaration, VariableDeclaration } from '@babel/types';
+export declare function determineModuleType(ast: ParseResult<t.File>): boolean;
+export type ImportItem = string | {
+    local: string;
+    imported: string;
+    source: string;
+};
+export declare function generateImports(needsImport: ImportItem[], isESM: boolean, importMap: Record<string, {
+    name: string;
+    source: string;
+}>): (t.ImportDeclaration | t.VariableDeclaration)[];
+export declare function generateImportMap(ast: ParseResult<t.File>, pkg: string): {
+    initialImports: string[];
+    importAlias: {
+        TComponent: string;
+        VarComponent: string;
+    };
+};
+export declare function insertImports(ast: ParseResult<t.File>, importNodes: (t.ImportDeclaration | t.VariableDeclaration)[]): void;
+export declare function createImports(ast: ParseResult<t.File>, needsImport: ImportItem[], importMap: Record<string, {
+    name: string;
+    source: string;
+}>): void;
+export interface ImportNameResult {
+    local: string;
+    original: string;
+}
+export declare function extractImportName(node: ImportDeclaration | VariableDeclaration, pkg: string, translationFuncs: string[]): ImportNameResult[];

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

@@ -0,0 +1,277 @@
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+import * as babel from '@babel/types';
+export function determineModuleType(ast) {
+    let isESM = false;
+    traverse(ast, {
+        ImportDeclaration() {
+            isESM = true;
+        },
+        ExportDefaultDeclaration() {
+            isESM = true;
+        },
+        ExportNamedDeclaration() {
+            isESM = true;
+        },
+    });
+    return isESM;
+}
+export function generateImports(needsImport, isESM, importMap) {
+    // Group imports by their source
+    const importsBySource = needsImport.reduce((acc, imp) => {
+        if (typeof imp === 'string') {
+            // Handle standard GT component imports
+            const importInfo = importMap[imp];
+            const source = importInfo.source;
+            if (!acc[source])
+                acc[source] = [];
+            acc[source].push({ local: imp, imported: importInfo.name });
+        }
+        else {
+            // Handle custom imports (like config)
+            const source = imp.source;
+            if (!acc[source])
+                acc[source] = [];
+            acc[source].push({ local: imp.local, imported: imp.imported });
+        }
+        return acc;
+    }, {});
+    // Generate import nodes for each source
+    const importNodes = Object.entries(importsBySource).map(([source, imports]) => {
+        if (isESM) {
+            return babel.importDeclaration(imports.map((imp) => imp.imported === 'default'
+                ? babel.importDefaultSpecifier(babel.identifier(imp.local))
+                : babel.importSpecifier(babel.identifier(imp.local), babel.identifier(imp.imported))), babel.stringLiteral(source));
+        }
+        else {
+            // For CommonJS, handle default imports differently
+            return babel.variableDeclaration('const', [
+                babel.variableDeclarator(imports.some((imp) => imp.imported === 'default')
+                    ? babel.identifier(imports[0].local)
+                    : babel.objectPattern(imports.map((imp) => babel.objectProperty(babel.identifier(imp.local), babel.identifier(imp.imported), false, imp.local === imp.imported))), babel.callExpression(babel.identifier('require'), [
+                    babel.stringLiteral(source),
+                ])),
+            ]);
+        }
+    });
+    return importNodes;
+}
+/*
+ * This function traverses the AST and records the relevant imports for the pkg.
+ * It also records the import aliases for the T and Var components. (in case of conflicts)
+ */
+export function generateImportMap(ast, pkg) {
+    const importAlias = { TComponent: 'T', VarComponent: 'Var' };
+    // Check existing imports
+    let initialImports = [];
+    traverse(ast, {
+        ImportDeclaration(path) {
+            const source = path.node.source.value;
+            if (source === pkg) {
+                initialImports = [
+                    ...initialImports,
+                    ...path.node.specifiers.map((spec) => {
+                        // For named imports (import { x as y }), use the original name
+                        if (babel.isImportSpecifier(spec)) {
+                            return babel.isIdentifier(spec.imported)
+                                ? spec.imported.name
+                                : spec.imported.value;
+                        }
+                        // For default imports, fall back to local name
+                        return spec.local.name;
+                    }),
+                ];
+            }
+            // Check for conflicting imports only if they're not from gt libraries
+            if (source !== pkg) {
+                path.node.specifiers.forEach((spec) => {
+                    if (babel.isImportSpecifier(spec) ||
+                        babel.isImportDefaultSpecifier(spec)) {
+                        if (spec.local.name === 'T')
+                            importAlias.TComponent = 'GTT';
+                        if (spec.local.name === 'Var')
+                            importAlias.VarComponent = 'GTVar';
+                    }
+                });
+            }
+        },
+        VariableDeclaration(path) {
+            const declaration = path.node.declarations[0];
+            if (!declaration)
+                return;
+            // Handle const { T, Var } = require('pkg')
+            if (babel.isCallExpression(declaration.init) &&
+                babel.isIdentifier(declaration.init.callee) &&
+                declaration.init.callee.name === 'require' &&
+                babel.isStringLiteral(declaration.init.arguments[0]) &&
+                declaration.init.arguments[0].value === pkg &&
+                babel.isObjectPattern(declaration.id)) {
+                initialImports = [
+                    ...initialImports,
+                    ...declaration.id.properties
+                        .map((prop) => {
+                        if (babel.isObjectProperty(prop) &&
+                            babel.isIdentifier(prop.key)) {
+                            return prop.key.name;
+                        }
+                        return '';
+                    })
+                        .filter(Boolean),
+                ];
+            }
+            // Handle const temp = require('pkg') followed by const { T, Var } = temp
+            if (babel.isCallExpression(declaration.init) &&
+                babel.isIdentifier(declaration.init.callee) &&
+                declaration.init.callee.name === 'require' &&
+                babel.isStringLiteral(declaration.init.arguments[0]) &&
+                declaration.init.arguments[0].value === pkg &&
+                babel.isIdentifier(declaration.id)) {
+                const requireVarName = declaration.id.name;
+                const parentBody = babel.isProgram(path.parent) || babel.isBlockStatement(path.parent)
+                    ? path.parent.body
+                    : [];
+                // Look for subsequent destructuring
+                for (const node of parentBody) {
+                    if (babel.isVariableDeclaration(node) &&
+                        node.declarations[0] &&
+                        babel.isObjectPattern(node.declarations[0].id) &&
+                        babel.isMemberExpression(node.declarations[0].init) &&
+                        babel.isIdentifier(node.declarations[0].init.object) &&
+                        node.declarations[0].init.object.name === requireVarName) {
+                        initialImports = [
+                            ...initialImports,
+                            ...node.declarations[0].id.properties
+                                .map((prop) => {
+                                if (babel.isObjectProperty(prop) &&
+                                    babel.isIdentifier(prop.key)) {
+                                    return prop.key.name;
+                                }
+                                return '';
+                            })
+                                .filter(Boolean),
+                        ];
+                    }
+                }
+            }
+            // Check for conflicting requires
+            if (babel.isCallExpression(declaration.init) &&
+                babel.isIdentifier(declaration.init.callee) &&
+                declaration.init.callee.name === 'require' &&
+                babel.isStringLiteral(declaration.init.arguments[0]) &&
+                declaration.init.arguments[0].value !== pkg &&
+                babel.isObjectPattern(declaration.id)) {
+                declaration.id.properties.forEach((prop) => {
+                    if (babel.isObjectProperty(prop) && babel.isIdentifier(prop.value)) {
+                        if (prop.value.name === 'T')
+                            importAlias.TComponent = 'GTT';
+                        if (prop.value.name === 'Var')
+                            importAlias.VarComponent = 'GTVar';
+                    }
+                });
+            }
+            // Add check for intermediate variable conflict
+            if (babel.isIdentifier(declaration.id)) {
+                if (declaration.id.name === 'T')
+                    importAlias.TComponent = 'GTT';
+                if (declaration.id.name === 'Var')
+                    importAlias.VarComponent = 'GTVar';
+            }
+        },
+    });
+    return { initialImports, importAlias };
+}
+export function insertImports(ast, importNodes) {
+    // Find the best position to insert the imports
+    let insertIndex = 0;
+    for (let i = 0; i < ast.program.body.length; i++) {
+        if (!babel.isImportDeclaration(ast.program.body[i])) {
+            insertIndex = i;
+            break;
+        }
+        insertIndex = i + 1;
+    }
+    // Insert all import nodes
+    ast.program.body.splice(insertIndex, 0, ...importNodes);
+}
+export function createImports(ast, needsImport, importMap) {
+    const isESM = determineModuleType(ast);
+    const importNodes = generateImports(needsImport, isESM, importMap);
+    insertImports(ast, importNodes);
+}
+export function extractImportName(node, pkg, translationFuncs) {
+    const results = [];
+    if (node.type === 'ImportDeclaration') {
+        // Handle ES6 imports
+        if (node.source.value.startsWith(pkg)) {
+            for (const specifier of node.specifiers) {
+                if (specifier.type === 'ImportSpecifier' &&
+                    'name' in specifier.imported &&
+                    translationFuncs.includes(specifier.imported.name)) {
+                    results.push({
+                        local: specifier.local.name,
+                        original: specifier.imported.name,
+                    });
+                }
+            }
+        }
+    }
+    else if (node.type === 'VariableDeclaration') {
+        // Handle CJS requires
+        for (const declaration of node.declarations) {
+            // Handle direct require with destructuring
+            if (declaration.init?.type === 'CallExpression' &&
+                declaration.init.callee.type === 'Identifier' &&
+                declaration.init.callee.name === 'require' &&
+                declaration.init.arguments[0]?.type === 'StringLiteral' &&
+                declaration.init.arguments[0].value.startsWith(pkg)) {
+                // Handle destructuring case: const { T } = require('gt-next')
+                if (declaration.id.type === 'ObjectPattern') {
+                    for (const prop of declaration.id.properties) {
+                        if (prop.type === 'ObjectProperty' &&
+                            prop.key.type === 'Identifier' &&
+                            translationFuncs.includes(prop.key.name) &&
+                            prop.value.type === 'Identifier') {
+                            results.push({
+                                local: prop.value.name,
+                                original: prop.key.name,
+                            });
+                        }
+                    }
+                }
+                // Handle intermediate variable case: const temp = require('gt-next')
+                else if (declaration.id.type === 'Identifier') {
+                    const requireVarName = declaration.id.name;
+                    const parentBody = node.parent?.body;
+                    if (parentBody) {
+                        for (let i = 0; i < parentBody.length; i++) {
+                            const stmt = parentBody[i];
+                            if (stmt.type === 'VariableDeclaration' &&
+                                stmt.declarations[0]?.init?.type === 'MemberExpression' &&
+                                stmt.declarations[0].init.object.type === 'Identifier' &&
+                                stmt.declarations[0].init.object.name === requireVarName &&
+                                stmt.declarations[0].init.property.type === 'Identifier' &&
+                                translationFuncs.includes(stmt.declarations[0].init.property.name)) {
+                                results.push({
+                                    local: stmt.declarations[0].id.name,
+                                    original: stmt.declarations[0].init.property.name,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            // Handle member expression assignment: const TranslateFunc = temp.T
+            if (declaration.init?.type === 'MemberExpression' &&
+                declaration.init.property.type === 'Identifier' &&
+                translationFuncs.includes(declaration.init.property.name) &&
+                declaration.id.type === 'Identifier') {
+                results.push({
+                    local: declaration.id.name,
+                    original: declaration.init.property.name,
+                });
+            }
+        }
+    }
+    return results;
+}

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

@@ -0,0 +1,21 @@
+import { Updates } from '../../../types/index.js';
+import * as t from '@babel/types';
+/**
+ * Builds a JSX tree from a given node, recursively handling children.
+ * @param node - The node to build the tree from
+ * @param unwrappedExpressions - An array to store unwrapped expressions
+ * @param updates - The updates array
+ * @param errors - The errors array
+ * @param file - The file name
+ * @param insideT - Whether the current node is inside a <T> component
+ * @returns The built JSX tree
+ */
+export declare function buildJSXTree(importAliases: Record<string, string>, node: any, unwrappedExpressions: string[], updates: Updates, errors: string[], warnings: Set<string>, file: string, insideT: boolean): {
+    expression?: boolean;
+    result?: string;
+    type?: string;
+    props?: {
+        children?: any;
+    };
+} | string | null;
+export declare function parseJSXElement(importAliases: Record<string, string>, node: t.JSXElement, updates: Updates, errors: string[], warnings: Set<string>, file: string): void;