gtx-cli 2.5.0-alpha.2 → 2.5.0

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

@@ -0,0 +1,199 @@
+import { isAcceptedPluralForm } from 'generaltranslation/internal';
+import { isElementNode, isExpressionNode, isMultiplicationNode, } from './types.js';
+// JSX whitespace characters (space, tab, newline, carriage return)
+// Does NOT include non-breaking space (U+00A0) which should be preserved
+const isJsxWhitespace = (char) => {
+    return char === ' ' || char === '\t' || char === '\n' || char === '\r';
+};
+const trimJsxWhitespace = (str, side = 'both') => {
+    let start = 0;
+    let end = str.length;
+    if (side === 'start' || side === 'both') {
+        while (start < end && isJsxWhitespace(str[start])) {
+            start++;
+        }
+    }
+    if (side === 'end' || side === 'both') {
+        while (end > start && isJsxWhitespace(str[end - 1])) {
+            end--;
+        }
+    }
+    return str.slice(start, end);
+};
+const hasNonJsxWhitespace = (str) => {
+    for (const char of str) {
+        if (!isJsxWhitespace(char))
+            return true;
+    }
+    return false;
+};
+export function trimJsxStringChild(child) {
+    if (!child.includes('\n') && !child.includes('\r')) {
+        return child;
+    }
+    // Normalize line endings to \n for consistency across platforms
+    let result = child.replace(/\r\n|\r/g, '\n');
+    // Collapse multiple spaces/tabs into a single space (but not nbsp)
+    result = result.replace(/[\t ]+/g, ' ');
+    let newResult = '';
+    let newline = false;
+    for (const char of result) {
+        if (char === '\n') {
+            if (hasNonJsxWhitespace(newResult))
+                newResult += ' ';
+            else
+                newResult = '';
+            newline = true;
+            continue;
+        }
+        if (!newline) {
+            newResult += char;
+            continue;
+        }
+        if (isJsxWhitespace(char))
+            continue;
+        newResult += char;
+        newline = false;
+    }
+    if (newline)
+        newResult = trimJsxWhitespace(newResult, 'end');
+    result = newResult;
+    // Collapse multiple spaces/tabs into a single space (but not nbsp)
+    result = result.replace(/[\t ]+/g, ' ');
+    return result;
+}
+/**
+ * Handles whitespace in children of a JSX element, and strips elements
+ * @param currentTree - The current tree to handle
+ * @returns The processed tree with whitespace handled
+ *
+ * For unresolved functions, we just make it so that Static has no children
+ *
+ * The typing was so much worse before this. Don't come for me. All I did was enforce the typing.
+ */
+export function handleChildrenWhitespace(currentTree, parentNodeType = undefined) {
+    if (Array.isArray(currentTree)) {
+        const childrenTypes = currentTree.map((child) => {
+            if (typeof child === 'string')
+                return 'text';
+            if (isExpressionNode(child))
+                return 'expression';
+            if (isElementNode(child))
+                return 'element';
+            if (isMultiplicationNode(child))
+                return 'multiplication';
+            return 'other';
+        });
+        const newChildren = [];
+        currentTree.forEach((child, index) => {
+            switch (childrenTypes[index]) {
+                case 'text':
+                    const textNode = child;
+                    if (parentNodeType === 'multiplication') {
+                        // This should be treated like a new tree (no parent here b/c its a new tree)
+                        const result = handleChildrenWhitespace(textNode);
+                        if (result)
+                            newChildren.push(result);
+                    }
+                    else {
+                        const string = trimJsxStringChild(textNode);
+                        if (string)
+                            newChildren.push(string);
+                    }
+                    break;
+                case 'expression':
+                    // Strip expressions
+                    const result = child.result;
+                    if (isMultiplicationNode(result)) {
+                        newChildren.push(handleChildrenWhitespace(result));
+                    }
+                    else if (typeof result === 'string') {
+                        newChildren.push(result);
+                    }
+                    else {
+                        // other case
+                        newChildren.push(result);
+                    }
+                    break;
+                case 'element':
+                    const newElement = handleChildrenWhitespace(child);
+                    newChildren.push(newElement);
+                    break;
+                case 'multiplication':
+                    // I dont think this case is possible, at least in the array case
+                    // Can only be child of element or multiplication nodes
+                    newChildren.push({
+                        nodeType: 'multiplication',
+                        branches: handleChildrenWhitespace(child.branches, 'multiplication'),
+                    });
+                    break;
+                case 'other':
+                    // Return number or boolean or null
+                    newChildren.push(child);
+                    break;
+            }
+        });
+        if (parentNodeType === 'multiplication') {
+            // Return the branches as an array
+            return newChildren;
+        }
+        return newChildren.length === 1 ? newChildren[0] : newChildren;
+    }
+    else if (isElementNode(currentTree)) {
+        // Process all props recursively
+        // What if there is a different component sharing the same name?
+        const elementIsPlural = currentTree.type === 'Plural';
+        const elementIsBranch = currentTree.type === 'Branch';
+        const processedProps = !currentTree.props
+            ? undefined
+            : Object.fromEntries(Object.entries(currentTree.props).map(([key, value]) => {
+                let shouldProcess = false;
+                // Process children
+                if (key === 'children')
+                    shouldProcess = true;
+                // Process plural children
+                if (elementIsPlural && isAcceptedPluralForm(key))
+                    shouldProcess = true;
+                // Process branch children
+                if (elementIsBranch && key !== 'branch')
+                    shouldProcess = true;
+                // Do not process raw strings
+                if (typeof value === 'string' && key !== 'children')
+                    shouldProcess = false;
+                // Process props
+                if (!shouldProcess) {
+                    return [key, value];
+                }
+                return [key, handleChildrenWhitespace(value)];
+            }));
+        return {
+            nodeType: 'element',
+            type: currentTree.type,
+            ...(processedProps ? { props: processedProps } : {}),
+        };
+    }
+    else if (isExpressionNode(currentTree)) {
+        // Strip expression
+        const result = currentTree.result;
+        if (isMultiplicationNode(result)) {
+            return handleChildrenWhitespace(result);
+        }
+        else if (typeof result === 'string') {
+            return result;
+        }
+        else {
+            return result;
+        }
+    }
+    else if (isMultiplicationNode(currentTree)) {
+        return {
+            nodeType: 'multiplication',
+            branches: handleChildrenWhitespace(currentTree.branches, 'multiplication'),
+        };
+    }
+    else if (typeof currentTree === 'string') {
+        return trimJsxStringChild(currentTree);
+    }
+    // null or number or boolean
+    return currentTree;
+}

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, curr, 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,61 @@
+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, callStack, updates, errors, warnings, file, insideT, parsingOptions, scopeNode, importedFunctionsMap, pkg, }: {
+    importAliases: Record<string, string>;
+    node: any;
+    callStack: string[];
+    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;