gtx-cli 1.2.13 → 1.2.15

package/dist/react/jsx/parse/parseStringFunction.js

@@ -1,118 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attributes = void 0;
-exports.parseStrings = parseStrings;
-const generaltranslation_1 = require("generaltranslation");
-const t = __importStar(require("@babel/types"));
-const evaluateJsx_1 = require("../evaluateJsx");
-const console_1 = require("../../../console");
-const generator_1 = __importDefault(require("@babel/generator"));
-exports.attributes = ['id', 'context'];
-/**
- * For the following example code:
- * const tx = useGT();
- * tx('string to translate', { id: 'exampleId', context: 'exampleContext' });
- *
- * This function will find all call expressions of useGT(), then find all call expressions
- * of the subsequent tx() calls, and append the content and metadata to the updates array.
- */
-function parseStrings(importName, path, updates, errors, file) {
-    path.scope.bindings[importName]?.referencePaths.forEach((refPath) => {
-        // Find call expressions of useGT() / await getGT()
-        const callExpr = refPath.findParent((p) => p.isCallExpression());
-        if (callExpr) {
-            // Get the parent, handling both await and non-await cases
-            const parentPath = callExpr.parentPath;
-            const effectiveParent = parentPath?.node.type === 'AwaitExpression'
-                ? parentPath.parentPath
-                : parentPath;
-            if (effectiveParent &&
-                effectiveParent.node.type === 'VariableDeclarator' &&
-                effectiveParent.node.id.type === 'Identifier') {
-                const tFuncName = effectiveParent.node.id.name;
-                // Get the scope from the variable declaration
-                const variableScope = effectiveParent.scope;
-                variableScope.bindings[tFuncName]?.referencePaths.forEach((tPath) => {
-                    if (tPath.parent.type === 'CallExpression' &&
-                        tPath.parent.arguments.length > 0) {
-                        const arg = tPath.parent.arguments[0];
-                        if (arg.type === 'StringLiteral' ||
-                            (t.isTemplateLiteral(arg) && arg.expressions.length === 0)) {
-                            const source = arg.type === 'StringLiteral'
-                                ? arg.value
-                                : arg.quasis[0].value.raw;
-                            // split the string into content (same as runtime behavior)
-                            const content = (0, generaltranslation_1.splitStringToContent)(source);
-                            // get metadata and id from options
-                            const options = tPath.parent.arguments[1];
-                            let metadata = {};
-                            if (options && options.type === 'ObjectExpression') {
-                                options.properties.forEach((prop) => {
-                                    if (prop.type === 'ObjectProperty' &&
-                                        prop.key.type === 'Identifier') {
-                                        const attribute = prop.key.name;
-                                        if (exports.attributes.includes(attribute) &&
-                                            t.isExpression(prop.value)) {
-                                            const result = (0, evaluateJsx_1.isStaticExpression)(prop.value);
-                                            if (!result.isStatic) {
-                                                errors.push((0, console_1.warnNonStaticExpressionSync)(file, attribute, (0, generator_1.default)(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                                            }
-                                            if (result.isStatic && result.value) {
-                                                metadata[attribute] = result.value;
-                                            }
-                                        }
-                                    }
-                                });
-                            }
-                            updates.push({
-                                dataFormat: 'JSX',
-                                source: content,
-                                metadata,
-                            });
-                        }
-                        else if (t.isTemplateLiteral(arg)) {
-                            // warn if template literal
-                            errors.push((0, console_1.warnTemplateLiteralSync)(file, (0, generator_1.default)(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-                        }
-                    }
-                });
-            }
-        }
-    });
-}

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

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

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleChildrenWhitespace = void 0;
-exports.trimJsxStringChild = trimJsxStringChild;
-const internal_1 = require("generaltranslation/internal");
-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
- */
-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((0, exports.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 && (0, internal_1.isAcceptedPluralForm)(key))
-                shouldProcess = true;
-            if (elementIsBranch && key !== 'branch')
-                shouldProcess = true;
-            // Add your validation logic here
-            if (shouldProcess) {
-                return [key, (0, exports.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;
-};
-exports.handleChildrenWhitespace = handleChildrenWhitespace;

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

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

@@ -1,319 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.determineModuleType = determineModuleType;
-exports.generateImports = generateImports;
-exports.generateImportMap = generateImportMap;
-exports.insertImports = insertImports;
-exports.createImports = createImports;
-exports.extractImportName = extractImportName;
-const traverse_1 = __importDefault(require("@babel/traverse"));
-const babel = __importStar(require("@babel/types"));
-function determineModuleType(ast) {
-    let isESM = false;
-    (0, traverse_1.default)(ast, {
-        ImportDeclaration() {
-            isESM = true;
-        },
-        ExportDefaultDeclaration() {
-            isESM = true;
-        },
-        ExportNamedDeclaration() {
-            isESM = true;
-        },
-    });
-    return isESM;
-}
-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)
- */
-function generateImportMap(ast, pkg) {
-    let importAlias = { TComponent: 'T', VarComponent: 'Var' };
-    // Check existing imports
-    let initialImports = [];
-    (0, traverse_1.default)(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 };
-}
-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);
-}
-function createImports(ast, needsImport, importMap) {
-    const isESM = determineModuleType(ast);
-    const importNodes = generateImports(needsImport, isESM, importMap);
-    insertImports(ast, importNodes);
-}
-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

@@ -1,13 +0,0 @@
-import { Updates } from '../../../types';
-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
- * @returns The built JSX tree
- */
-export declare function buildJSXTree(importAliases: Record<string, string>, node: any, unwrappedExpressions: string[], updates: Updates, errors: string[], file: string): any;
-export declare function parseJSXElement(importAliases: Record<string, string>, node: t.JSXElement, updates: Updates, errors: string[], file: string): void;