gtx-cli 2.6.31 → 2.7.0

package/dist/react/jsx/utils/jsxParsing/parseTProps.d.ts

@@ -1,8 +0,0 @@
-import { Metadata } from 'generaltranslation/types';
-import * as t from '@babel/types';
-export declare function parseTProps({ openingElement, metadata, componentErrors, file, }: {
-    openingElement: t.JSXOpeningElement;
-    metadata: Metadata;
-    componentErrors: string[];
-    file: string;
-}): void;

package/dist/react/jsx/utils/jsxParsing/parseTProps.js

@@ -1,65 +0,0 @@
-import * as t from '@babel/types';
-import generateModule from '@babel/generator';
-// Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
-import { GT_ATTRIBUTES } from '../constants.js';
-import { mapAttributeName } from '../mapAttributeName.js';
-import { isStaticExpression } from '../../evaluateJsx.js';
-import { warnInvalidMaxCharsSync, warnVariablePropSync, } from '../../../../console/index.js';
-import { isNumberLiteral } from '../isNumberLiteral.js';
-// Parse the props of a <T> component
-export function parseTProps({ openingElement, metadata, componentErrors, file, }) {
-    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)) {
-                metadata[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 = generate(expr).code;
-                // Only check for static expressions on id and context and maxChars props
-                if (GT_ATTRIBUTES.includes(attrName)) {
-                    const staticAnalysis = isStaticExpression(expr);
-                    if (!staticAnalysis.isStatic) {
-                        componentErrors.push(warnVariablePropSync(file, attrName, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
-                    }
-                    // Use the static value if available
-                    if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
-                        // Check for invalid maxChars values
-                        if (attrName === '$maxChars' || attrName === 'maxChars') {
-                            if (typeof staticAnalysis.value === 'string' &&
-                                (isNaN(Number(staticAnalysis.value)) ||
-                                    (t.isExpression(expr) && !isNumberLiteral(expr)) ||
-                                    !Number.isInteger(Number(staticAnalysis.value)))) {
-                                componentErrors.push(warnInvalidMaxCharsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
-                            }
-                            else {
-                                // Add the maxChars value to the metadata
-                                metadata[mapAttributeName(attrName)] = Math.abs(Number(staticAnalysis.value));
-                            }
-                        }
-                        else {
-                            // Add the $context or $id or other attributes value to the metadata
-                            metadata[mapAttributeName(attrName)] = staticAnalysis.value;
-                        }
-                    }
-                    else {
-                        // Only store the code if we couldn't extract a static value
-                        metadata[attrName] = code;
-                    }
-                }
-                else {
-                    // For other attributes that aren't id or context
-                    metadata[attrName] = code;
-                }
-            }
-        }
-    });
-}

package/dist/react/jsx/utils/jsxParsing/removeNullChildrenFields.d.ts

@@ -1,2 +0,0 @@
-import { JsxChildren } from 'generaltranslation/types';
-export declare function removeNullChildrenFields(tree: JsxChildren): JsxChildren;

package/dist/react/jsx/utils/jsxParsing/removeNullChildrenFields.js

@@ -1,61 +0,0 @@
-import { isVariable } from 'generaltranslation/internal';
-export function removeNullChildrenFields(tree) {
-    return handleChildren(tree);
-    function handleChildren(children) {
-        if (Array.isArray(children)) {
-            return children.filter((child) => child != null).map(handleChild);
-        }
-        return handleChild(children);
-    }
-    function handleChild(child) {
-        if (typeof child === 'string') {
-            return child;
-        }
-        if (typeof child !== 'object' || child === null) {
-            return child;
-        }
-        if (isVariable(child)) {
-            return child;
-        }
-        // other fields
-        let t;
-        if (child && 't' in child && child.t != null) {
-            t = child.t;
-        }
-        let i;
-        if (child && 'i' in child && child.i != null) {
-            i = child.i;
-        }
-        // gtprop
-        let d;
-        if (child && 'd' in child && child.d != null) {
-            let b;
-            if (child.d && 'b' in child.d && child.d.b != null) {
-                b = {
-                    ...Object.fromEntries(Object.entries(child.d.b).map(([key, value]) => [
-                        key,
-                        handleChildren(value),
-                    ])),
-                };
-            }
-            d = {
-                ...(b != null && { b }),
-                ...(child.d?.t != null && { t: child.d.t }),
-                ...Object.fromEntries(Object.entries(child.d)
-                    .filter(([key, value]) => key !== 'b' && key !== 't' && value != null)
-                    .map(([key, value]) => [key, value])),
-            };
-        }
-        // children
-        let c;
-        if (child && 'c' in child && child.c != null) {
-            c = handleChildren(child.c);
-        }
-        return {
-            ...(t != null && { t }),
-            ...(i != null && { i }),
-            ...(d != null && { d }),
-            ...(c != null && { c }),
-        };
-    }
-}

package/dist/react/jsx/utils/jsxParsing/types.d.ts

@@ -1,48 +0,0 @@
-type MultiplicationNode = {
-    nodeType: 'multiplication';
-    branches: (JsxTree | MultiplicationNode)[];
-};
-type ExpressionNode = {
-    nodeType: 'expression';
-    result: string | number | boolean | MultiplicationNode | null;
-};
-type ElementNode = {
-    nodeType: 'element';
-    type: string;
-    props?: {
-        children?: JsxTree | MultiplicationNode | (JsxTree | MultiplicationNode)[];
-        [key: string]: any;
-    };
-};
-type JsxTree = ElementNode | ExpressionNode | string | number | boolean | null;
-export type { MultiplicationNode, ExpressionNode, ElementNode, JsxTree };
-declare function isElementNode(node: JsxTree | MultiplicationNode): node is ElementNode;
-declare function isExpressionNode(node: JsxTree | MultiplicationNode): node is ExpressionNode;
-declare function isMultiplicationNode(node: JsxTree | MultiplicationNode): node is MultiplicationNode;
-export { isElementNode, isExpressionNode, isMultiplicationNode };
-type WhitespaceMultiplicationNode = {
-    nodeType: 'multiplication';
-    branches: (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
-};
-type WhitespaceJsxTree = {
-    nodeType?: 'element';
-    type: string;
-    props?: {
-        children?: (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
-        [key: string]: any;
-    };
-};
-type WhitespaceJsxTreeResult = WhitespaceJsxTree | string | number | boolean | null;
-export type { WhitespaceMultiplicationNode, WhitespaceJsxTree, WhitespaceJsxTreeResult, };
-declare function isWhitespaceJsxTree(node: WhitespaceJsxTreeResult | WhitespaceMultiplicationNode): node is WhitespaceJsxTree;
-declare function isWhitespaceMultiplicationNode(node: WhitespaceJsxTreeResult | WhitespaceMultiplicationNode): node is WhitespaceMultiplicationNode;
-export { isWhitespaceJsxTree, isWhitespaceMultiplicationNode };
-type MultipliedTree = {
-    nodeType?: 'element';
-    type: string;
-    props?: {
-        children?: MultipliedTreeNode;
-    };
-};
-type MultipliedTreeNode = MultipliedTree | string | number | boolean | null;
-export type { MultipliedTree, MultipliedTreeNode };

package/dist/react/jsx/utils/jsxParsing/types.js

@@ -1,34 +0,0 @@
-// ----- Helpers ----- //
-function isElementNode(node) {
-    return (typeof node === 'object' &&
-        node !== null &&
-        'nodeType' in node &&
-        node.nodeType === 'element');
-}
-function isExpressionNode(node) {
-    return (typeof node === 'object' &&
-        node !== null &&
-        'nodeType' in node &&
-        node.nodeType === 'expression');
-}
-function isMultiplicationNode(node) {
-    return (typeof node === 'object' &&
-        node !== null &&
-        'nodeType' in node &&
-        node.nodeType === 'multiplication');
-}
-export { isElementNode, isExpressionNode, isMultiplicationNode };
-// ----- Helpers ----- //
-function isWhitespaceJsxTree(node) {
-    return (typeof node === 'object' &&
-        node !== null &&
-        'nodeType' in node &&
-        node.nodeType === 'element');
-}
-function isWhitespaceMultiplicationNode(node) {
-    return (typeof node === 'object' &&
-        node !== null &&
-        'nodeType' in node &&
-        node.nodeType === 'multiplication');
-}
-export { isWhitespaceJsxTree, isWhitespaceMultiplicationNode };

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

@@ -1,11 +0,0 @@
-/**
- * Type logic implementation
- */
-type MapAttributeName<T extends string> = T extends '$id' ? 'id' : T extends '$context' ? 'context' : T extends '$maxChars' ? 'maxChars' : T;
-/**
- * Map the attribute name to the corresponding attribute name in the metadata
- * @param attrName - The attribute name to map
- * @returns The mapped attribute name
- */
-export declare function mapAttributeName<T extends string>(attrName: T): MapAttributeName<T>;
-export {};

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

@@ -1,12 +0,0 @@
-export function mapAttributeName(attrName) {
-    switch (attrName) {
-        case '$id':
-            return 'id';
-        case '$context':
-            return 'context';
-        case '$maxChars':
-            return 'maxChars';
-        default:
-            return attrName;
-    }
-}

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

@@ -1,31 +0,0 @@
-import * as t from '@babel/types';
-import { ParseResult } from '@babel/parser';
-import { ImportDeclaration, VariableDeclaration } from '@babel/types';
-import { GTLibrary } from '../../../types/libraries.js';
-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, pkgs: GTLibrary[], translationFuncs: string[]): ImportNameResult[];

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

@@ -1,278 +0,0 @@
-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, pkgs, translationFuncs) {
-    const results = [];
-    if (node.type === 'ImportDeclaration') {
-        // Handle ES6 imports
-        if (pkgs.some((pkg) => 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' &&
-                pkgs.some((pkg) => 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/parseDeclareStatic.d.ts

@@ -1,15 +0,0 @@
-import * as t from '@babel/types';
-import { NodePath } from '@babel/traverse';
-import { ParsingConfigOptions } from '../../../types/parsing.js';
-import { StringNode } from './types.js';
-export type StringTree = (string | StringTree)[];
-/**
- * Checks if an expression is static or uses declareStatic
- * Returns a Node representing the parsed expression
- * @param expr - The expression to check
- * @param tPath - NodePath for scope resolution
- * @param file - Current file path
- * @param parsingOptions - Parsing configuration
- * @returns Node | null - The parsed node, or null if invalid
- */
-export declare function handleStaticExpression(expr: t.Expression, tPath: NodePath, file: string, parsingOptions: ParsingConfigOptions, errors: string[]): StringNode | null;