gtx-cli 2.5.0-alpha.0 → 2.5.0-alpha.2

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,47 +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, mapAttributeName } from '../constants.js';
-import { isStaticExpression } from '../../evaluateJsx.js';
-import { warnVariablePropSync } from '../../../../console/index.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 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) {
-                        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/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/resolveImportPath.d.ts

@@ -1,11 +0,0 @@
-import { ParsingConfigOptions } from '../../../types/parsing.js';
-/**
- * Resolves import paths to absolute file paths using battle-tested libraries.
- * Handles relative paths, TypeScript paths, and node module resolution.
- *
- * Examples:
- * - './constants' -> '/full/path/to/constants.ts'
- * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
- * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
- */
-export declare function resolveImportPath(currentFile: string, importPath: string, parsingOptions: ParsingConfigOptions, resolveImportPathCache: Map<string, string | null>): string | null;

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

@@ -1,111 +0,0 @@
-import { createMatchPath, loadConfig } from 'tsconfig-paths';
-import fs from 'node:fs';
-import path from 'node:path';
-import resolve from 'resolve';
-import enhancedResolve from 'enhanced-resolve';
-const { ResolverFactory } = enhancedResolve;
-/**
- * Resolves import paths to absolute file paths using battle-tested libraries.
- * Handles relative paths, TypeScript paths, and node module resolution.
- *
- * Examples:
- * - './constants' -> '/full/path/to/constants.ts'
- * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
- * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
- */
-export function resolveImportPath(currentFile, importPath, parsingOptions, resolveImportPathCache) {
-    // Check cache first
-    const cacheKey = `${currentFile}::${importPath}`;
-    if (resolveImportPathCache.has(cacheKey)) {
-        return resolveImportPathCache.get(cacheKey);
-    }
-    const basedir = path.dirname(currentFile);
-    const extensions = ['.tsx', '.ts', '.jsx', '.js'];
-    const mainFields = ['module', 'main'];
-    let result = null;
-    // 1. Try tsconfig-paths resolution first (handles TypeScript path mapping)
-    const tsConfigResult = loadConfig(basedir);
-    if (tsConfigResult.resultType === 'success') {
-        const matchPath = createMatchPath(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, mainFields);
-        // First try without any extension
-        let tsResolved = matchPath(importPath);
-        if (tsResolved && fs.existsSync(tsResolved)) {
-            result = tsResolved;
-            resolveImportPathCache.set(cacheKey, result);
-            return result;
-        }
-        // Then try with each extension
-        for (const ext of extensions) {
-            tsResolved = matchPath(importPath + ext);
-            if (tsResolved && fs.existsSync(tsResolved)) {
-                result = tsResolved;
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            // Also try the resolved path with extension
-            tsResolved = matchPath(importPath);
-            if (tsResolved) {
-                const resolvedWithExt = tsResolved + ext;
-                if (fs.existsSync(resolvedWithExt)) {
-                    result = resolvedWithExt;
-                    resolveImportPathCache.set(cacheKey, result);
-                    return result;
-                }
-            }
-        }
-    }
-    // 2. Try enhanced-resolve (handles package.json exports field and modern resolution)
-    try {
-        const resolver = ResolverFactory.createResolver({
-            useSyncFileSystemCalls: true,
-            fileSystem: fs,
-            extensions,
-            // Include 'development' condition to resolve to source files in monorepos
-            conditionNames: parsingOptions.conditionNames, // defaults to ['browser', 'module', 'import', 'require', 'default']. See generateSettings.ts for more details
-            exportsFields: ['exports'],
-            mainFields,
-        });
-        const resolved = resolver.resolveSync({}, basedir, importPath);
-        if (resolved) {
-            result = resolved;
-            resolveImportPathCache.set(cacheKey, result);
-            return result;
-        }
-    }
-    catch {
-        // Fall through to next resolution strategy
-    }
-    // 3. Fallback to Node.js resolution (handles relative paths and node_modules)
-    try {
-        result = resolve.sync(importPath, { basedir, extensions });
-        resolveImportPathCache.set(cacheKey, result);
-        return result;
-    }
-    catch {
-        // If resolution fails, try to manually replace .js/.jsx with .ts/.tsx for source files
-        if (importPath.endsWith('.js')) {
-            const tsPath = importPath.replace(/\.js$/, '.ts');
-            try {
-                result = resolve.sync(tsPath, { basedir, extensions });
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        else if (importPath.endsWith('.jsx')) {
-            const tsxPath = importPath.replace(/\.jsx$/, '.tsx');
-            try {
-                result = resolve.sync(tsxPath, { basedir, extensions });
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        resolveImportPathCache.set(cacheKey, null);
-        return null;
-    }
-}