gt 0.10.0 → 2.7.0

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

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

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

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

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

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

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

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

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

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

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

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

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