gtx-cli 1.2.14 → 1.2.15

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

@@ -1,250 +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.buildJSXTree = buildJSXTree;
-exports.parseJSXElement = parseJSXElement;
-const generator_1 = __importDefault(require("@babel/generator"));
-const t = __importStar(require("@babel/types"));
-const addGTIdentifierToSyntaxTree_1 = __importDefault(require("../../data-_gt/addGTIdentifierToSyntaxTree"));
-const console_1 = require("../../../console");
-const internal_1 = require("generaltranslation/internal");
-const trimJsxStringChildren_1 = require("../trimJsxStringChildren");
-const evaluateJsx_1 = require("../evaluateJsx");
-// Valid variable components
-const VARIABLE_COMPONENTS = ['Var', 'DateTime', 'Currency', 'Num'];
-/**
- * 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
- */
-function buildJSXTree(importAliases, node, unwrappedExpressions, updates, errors, file) {
-    if (t.isJSXExpressionContainer(node)) {
-        // Skip JSX comments
-        if (t.isJSXEmptyExpression(node.expression)) {
-            return null;
-        }
-        const expr = node.expression;
-        const staticAnalysis = (0, evaluateJsx_1.isStaticExpression)(expr);
-        if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
-            // Preserve the exact whitespace for static string expressions
-            return {
-                expression: true,
-                result: staticAnalysis.value,
-            };
-        }
-        // Keep existing behavior for non-static expressions
-        const code = (0, generator_1.default)(node).code;
-        unwrappedExpressions.push(code); // Keep track of unwrapped expressions for error reporting
-        return code;
-    }
-    else if (t.isJSXText(node)) {
-        // Updated JSX Text handling
-        // JSX Text handling following React's rules
-        let text = node.value;
-        return text;
-    }
-    else if (t.isJSXElement(node)) {
-        const element = node;
-        const elementName = element.openingElement.name;
-        let typeName;
-        if (t.isJSXIdentifier(elementName)) {
-            typeName = elementName.name;
-        }
-        else if (t.isJSXMemberExpression(elementName)) {
-            typeName = (0, generator_1.default)(elementName).code;
-        }
-        else {
-            typeName = null;
-        }
-        // Convert from alias to original name
-        const componentType = importAliases[typeName ?? ''];
-        // If this JSXElement is one of the recognized variable components,
-        const elementIsVariable = VARIABLE_COMPONENTS.includes(componentType);
-        const props = {};
-        const elementIsPlural = componentType === 'Plural';
-        const elementIsBranch = componentType === 'Branch';
-        element.openingElement.attributes.forEach((attr) => {
-            if (t.isJSXAttribute(attr)) {
-                const attrName = attr.name.name;
-                let attrValue = null;
-                if (attr.value) {
-                    if (t.isStringLiteral(attr.value)) {
-                        attrValue = attr.value.value;
-                    }
-                    else if (t.isJSXExpressionContainer(attr.value)) {
-                        if ((elementIsPlural && (0, internal_1.isAcceptedPluralForm)(attrName)) ||
-                            (elementIsBranch && attrName !== 'branch')) {
-                            // Make sure that variable strings like {`I have ${count} book`} are invalid!
-                            if (t.isTemplateLiteral(attr.value.expression) &&
-                                !(0, evaluateJsx_1.isStaticExpression)(attr.value.expression).isStatic) {
-                                unwrappedExpressions.push((0, generator_1.default)(attr.value).code);
-                            }
-                        }
-                        attrValue = buildJSXTree(importAliases, attr.value.expression, unwrappedExpressions, updates, errors, file);
-                    }
-                }
-                props[attrName] = attrValue;
-            }
-        });
-        if (elementIsVariable) {
-            parseJSXElement(importAliases, element, updates, errors, file);
-            return {
-                type: componentType,
-                props,
-            };
-        }
-        const children = element.children
-            .map((child) => buildJSXTree(importAliases, child, unwrappedExpressions, updates, errors, file))
-            .filter((child) => child !== null && child !== '');
-        if (children.length === 1) {
-            props.children = children[0];
-        }
-        else if (children.length > 1) {
-            props.children = children;
-        }
-        return {
-            type: componentType,
-            props,
-        };
-    }
-    // If it's a JSX fragment
-    else if (t.isJSXFragment(node)) {
-        const children = node.children
-            .map((child) => buildJSXTree(importAliases, child, unwrappedExpressions, updates, errors, file))
-            .filter((child) => child !== null && child !== '');
-        const props = {};
-        if (children.length === 1) {
-            props.children = children[0];
-        }
-        else if (children.length > 1) {
-            props.children = children;
-        }
-        return {
-            type: '',
-            props,
-        };
-    }
-    // If it's a string literal (standalone)
-    else if (t.isStringLiteral(node)) {
-        return node.value;
-    }
-    // If it's some other JS expression
-    else if (t.isIdentifier(node) ||
-        t.isMemberExpression(node) ||
-        t.isCallExpression(node) ||
-        t.isBinaryExpression(node) ||
-        t.isLogicalExpression(node) ||
-        t.isConditionalExpression(node)) {
-        return (0, generator_1.default)(node).code;
-    }
-    else {
-        return (0, generator_1.default)(node).code;
-    }
-}
-// end buildJSXTree
-// Parses a JSX element and adds it to the updates array
-function parseJSXElement(importAliases, node, updates, errors, file) {
-    const openingElement = node.openingElement;
-    const name = openingElement.name;
-    // Only proceed if it's <T> ...
-    if (name.type === 'JSXIdentifier' && importAliases[name.name] === 'T') {
-        const componentObj = { props: {} };
-        // We'll track this flag to know if any unwrapped {variable} is found in children
-        const unwrappedExpressions = [];
-        // Gather <T>'s props
-        openingElement.attributes.forEach((attr) => {
-            if (!t.isJSXAttribute(attr))
-                return;
-            const attrName = attr.name.name;
-            if (typeof attrName !== 'string')
-                return;
-            if (attr.value) {
-                // If it's a plain string literal like id="hello"
-                if (t.isStringLiteral(attr.value)) {
-                    componentObj.props[attrName] = attr.value.value;
-                }
-                // If it's an expression container like id={"hello"}, id={someVar}, etc.
-                else if (t.isJSXExpressionContainer(attr.value)) {
-                    const expr = attr.value.expression;
-                    const code = (0, generator_1.default)(expr).code;
-                    // Only check for static expressions on id and context props
-                    if (attrName === 'id' || attrName === 'context') {
-                        const staticAnalysis = (0, evaluateJsx_1.isStaticExpression)(expr);
-                        if (!staticAnalysis.isStatic) {
-                            errors.push((0, console_1.warnVariablePropSync)(file, attrName, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
-                        }
-                        // Use the static value if available
-                        if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
-                            componentObj.props[attrName] = staticAnalysis.value;
-                        }
-                        else {
-                            // Only store the code if we couldn't extract a static value
-                            componentObj.props[attrName] = code;
-                        }
-                    }
-                    else {
-                        // For other attributes that aren't id or context
-                        componentObj.props[attrName] = code;
-                    }
-                }
-            }
-        });
-        // Build the JSX tree for this component
-        const initialTree = buildJSXTree(importAliases, node, unwrappedExpressions, updates, errors, file).props.children;
-        const whitespaceHandledTree = (0, trimJsxStringChildren_1.handleChildrenWhitespace)(initialTree);
-        const tree = (0, addGTIdentifierToSyntaxTree_1.default)(whitespaceHandledTree);
-        componentObj.tree = tree.length === 1 ? tree[0] : tree;
-        const id = componentObj.props.id;
-        // If we found an unwrapped expression, skip
-        if (unwrappedExpressions.length > 0) {
-            errors.push((0, console_1.warnHasUnwrappedExpressionSync)(file, unwrappedExpressions, id, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
-        }
-        if (errors.length > 0)
-            return;
-        // <T> is valid here
-        updates.push({
-            dataFormat: 'JSX',
-            source: componentObj.tree,
-            metadata: componentObj.props,
-        });
-    }
-}

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

@@ -1,12 +0,0 @@
-import { NodePath } from '@babel/traverse';
-import { Updates } from '../../../types';
-export declare const attributes: string[];
-/**
- * For the following example code:
- * const t = useGT();
- * t('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.
- */
-export declare function parseStrings(importName: string, path: NodePath, updates: Updates, errors: string[], file: string): void;

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

@@ -1,121 +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 t = useGT();
- * t('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}`));
-                        }
-                        else {
-                            errors.push((0, console_1.warnNonStringSync)(file, (0, generator_1.default)(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-                        }
-                    }
-                });
-            }
-        }
-    });
-}

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

@@ -1,51 +0,0 @@
-import * as t from '@babel/types';
-import { ImportItem } from './utils/parseAst';
-/**
- * Recursively wraps a JSX element with a <T> component and unique id
- * @param node - The JSX element to wrap
- * @param updates - The updates array
- * @param errors - The errors array
- * @param file - The file name
- * @param options - Optional component names for T and Var
- */
-export interface WrapResult {
-    node: t.JSXElement | t.JSXFragment;
-    hasMeaningfulContent: boolean;
-    wrappedInT: boolean;
-}
-/**
- * Recursively traverse a JSX element and wrap variables with a <Var> component
- * @param node - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export declare function wrapJsxElement(node: t.JSXElement | t.JSXFragment, options: {
-    createIds: boolean;
-    TComponent?: string;
-    VarComponent?: string;
-    idPrefix: string;
-    idCount: number;
-    usedImports: ImportItem[];
-    modified: boolean;
-    warnings: string[];
-    file: string;
-}, isMeaningful: (node: t.Node) => boolean, mark: boolean): WrapResult;
-/**
- * Wraps a JSX element with a <T> component and unique id
- * @param rootNode - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export declare function handleJsxElement(rootNode: t.JSXElement | t.JSXFragment, options: {
-    createIds: boolean;
-    usedImports: ImportItem[];
-    TComponent?: string;
-    VarComponent?: string;
-    idPrefix: string;
-    idCount: number;
-    modified: boolean;
-    warnings: string[];
-    file: string;
-}, isMeaningful: (node: t.Node) => boolean): WrapResult;