gtx-cli 2.4.14 → 2.5.0-alpha.0

package/dist/react/jsx/utils/jsxParsing/multiplication/findMultiplicationNode.d.ts

@@ -0,0 +1,13 @@
+import { WhitespaceJsxTreeResult, WhitespaceMultiplicationNode } from '../types.js';
+export type MultiplicationNodeResult = {
+    parent: any | undefined;
+    key: string | undefined;
+    node: WhitespaceMultiplicationNode;
+};
+/**
+ * Finds the immediate multiplication node from the given root (eg no nested multiplication nodes)
+ * TODO: I am sure there is some optimization to be done here
+ *
+ * Maybe there is an optimization here with caching used paths btwn calls
+ */
+export declare function findMultiplicationNode(root: WhitespaceJsxTreeResult | WhitespaceMultiplicationNode | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[]): MultiplicationNodeResult | undefined;

package/dist/react/jsx/utils/jsxParsing/multiplication/findMultiplicationNode.js

@@ -0,0 +1,42 @@
+import { isWhitespaceMultiplicationNode, isWhitespaceJsxTree, } from '../types.js';
+/**
+ * Finds the immediate multiplication node from the given root (eg no nested multiplication nodes)
+ * TODO: I am sure there is some optimization to be done here
+ *
+ * Maybe there is an optimization here with caching used paths btwn calls
+ */
+export function findMultiplicationNode(root) {
+    // Entry point
+    return handleChildren(root, undefined, undefined);
+    // Helper function to handle children
+    function handleChildren(curr, parent, key) {
+        if (Array.isArray(curr)) {
+            for (const [index, child] of Object.entries(curr)) {
+                const result = handleChild(child, parent, index);
+                if (result)
+                    return result;
+            }
+            return undefined;
+        }
+        else {
+            return handleChild(curr, parent, key);
+        }
+    }
+    // Helper function to handle a single child
+    function handleChild(curr, parent, key) {
+        if (isWhitespaceMultiplicationNode(curr)) {
+            return { parent, key, node: curr };
+        }
+        else if (isWhitespaceJsxTree(curr)) {
+            if (curr.props?.children) {
+                return handleChildren(curr.props.children, curr.props, 'children');
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+}

package/dist/react/jsx/utils/jsxParsing/multiplication/multiplyJsxTree.d.ts

@@ -0,0 +1,5 @@
+import { MultipliedTreeNode, WhitespaceJsxTreeResult } from '../types.js';
+/**
+ * Given a JSX tree, multiply the static function nodes
+ */
+export declare function multiplyJsxTree(tree: WhitespaceJsxTreeResult | WhitespaceJsxTreeResult[]): MultipliedTreeNode[];

package/dist/react/jsx/utils/jsxParsing/multiplication/multiplyJsxTree.js

@@ -0,0 +1,69 @@
+import { findMultiplicationNode } from './findMultiplicationNode.js';
+/**
+ * Given a JSX tree, multiply the static function nodes
+ */
+export function multiplyJsxTree(tree) {
+    if (!Array.isArray(tree)) {
+        return multiplyBranches([tree]);
+    }
+    else {
+        // when tree is an array, this is just sibbling elements within the <T>, so we need to treat them as a single branch
+        const wrapperElement = {
+            nodeType: 'element',
+            type: 'T',
+            props: {
+                children: tree,
+            },
+        };
+        // Multiply the wrapper element
+        const multipliedBranches = multiplyBranches([
+            wrapperElement,
+        ]);
+        // Unwrap the branches
+        return multipliedBranches.map((branch) => branch.props.children);
+    }
+}
+/**
+ * Given a list of branches, multiply recursively (DFS)
+ * @param branches
+ */
+function multiplyBranches(branches) {
+    // Queue of branches to process
+    const branchQueue = branches;
+    // Finalized branches
+    const newBranches = [];
+    // Process branches until exhausted
+    while (branchQueue.length) {
+        // Pop the next branch
+        const branch = branchQueue.shift();
+        // Get closest multiplication node
+        const currentNode = findMultiplicationNode(branch);
+        // No multiplication nodes, just add the branch to the final list
+        if (!currentNode) {
+            newBranches.push(branch);
+            continue;
+        }
+        const { node, parent, key } = currentNode;
+        // Recursive call
+        const subBranches = multiplyBranches(node.branches);
+        // For every sub branch, create a new cloned branch
+        for (const subBranch of subBranches) {
+            // Placeholder for the new branch
+            let newBranch = undefined;
+            // Create a clone of the original with the sub branch swapped in
+            if (parent === undefined || key === undefined) {
+                // This means the subBranch directly replaces the branch itself
+                newBranches.push(subBranch);
+            }
+            else {
+                // Replace the multiplication node with the sub branch
+                parent[key] = subBranch;
+                // eslint-disable-next-line no-undef
+                newBranch = structuredClone(branch);
+                // Add the new branch to the list
+                branchQueue.push(newBranch);
+            }
+        }
+    }
+    return newBranches;
+}

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

@@ -0,0 +1,60 @@
+import { Updates } from '../../../../types/index.js';
+import * as t from '@babel/types';
+import { NodePath } from '@babel/traverse';
+import { ParsingConfigOptions } from '../../../../types/parsing.js';
+import traverseModule from '@babel/traverse';
+import { JsxTree } from './types.js';
+/**
+ * Entry point for JSX parsing
+ */
+export declare function parseTranslationComponent({ originalName, importAliases, localName, path, updates, errors, warnings, file, parsingOptions, pkg, }: {
+    ast: any;
+    pkg: 'gt-react' | 'gt-next';
+    originalName: string;
+    importAliases: Record<string, string>;
+    path: traverseModule.NodePath<traverseModule.Node>;
+    localName: string;
+    updates: Updates;
+    errors: string[];
+    warnings: Set<string>;
+    file: string;
+    parsingOptions: ParsingConfigOptions;
+}): void;
+/**
+ * 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
+ * @param insideT - Whether the current node is inside a <T> component
+ * @returns The built JSX tree
+ */
+export declare function buildJSXTree({ importAliases, node, unwrappedExpressions, visited, updates, errors, warnings, file, insideT, parsingOptions, scopeNode, importedFunctionsMap, pkg, }: {
+    importAliases: Record<string, string>;
+    node: any;
+    unwrappedExpressions: string[];
+    visited: Set<string>;
+    updates: Updates;
+    errors: string[];
+    warnings: Set<string>;
+    file: string;
+    insideT: boolean;
+    parsingOptions: ParsingConfigOptions;
+    scopeNode: NodePath;
+    importedFunctionsMap: Map<string, string>;
+    pkg: 'gt-react' | 'gt-next';
+}): JsxTree;
+export declare function parseJSXElement({ importAliases, node, originalName, pkg, updates, errors, warnings, file, parsingOptions, scopeNode, importedFunctionsMap, }: {
+    importAliases: Record<string, string>;
+    node: t.JSXElement;
+    originalName: string;
+    pkg: 'gt-react' | 'gt-next';
+    updates: Updates;
+    errors: string[];
+    warnings: Set<string>;
+    file: string;
+    parsingOptions: ParsingConfigOptions;
+    scopeNode: NodePath<t.JSXElement>;
+    importedFunctionsMap: Map<string, string>;
+}): void;