gtx-cli 2.6.29 → 2.6.30-alpha.0

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

@@ -1,91 +0,0 @@
-import traverseModule from '@babel/traverse';
-import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_REGISTRATION_FUNCTION, TRANSLATION_COMPONENT, } from '../../jsx/utils/constants.js';
-import { extractImportName } from './parseAst.js';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
-/**
- * Constructs tracking for gt related variables of interest
- * inlineTranslationPaths: these are string-related translation functions
- * translationComponentPaths: these are just <T> components
- * importAliases: any other GT related imports
- */
-export function getPathsAndAliases(ast, pkgs) {
-    // First pass: collect imports and process translation functions
-    const importAliases = {};
-    const inlineTranslationPaths = [];
-    const translationComponentPaths = [];
-    traverse(ast, {
-        ImportDeclaration(path) {
-            if (pkgs.some((pkg) => path.node.source.value.startsWith(pkg))) {
-                const importName = extractImportName(path.node, pkgs, GT_TRANSLATION_FUNCS);
-                for (const name of importName) {
-                    if (name.original === INLINE_TRANSLATION_HOOK ||
-                        name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
-                        name.original === INLINE_MESSAGE_HOOK ||
-                        name.original === INLINE_MESSAGE_HOOK_ASYNC ||
-                        name.original === MSG_REGISTRATION_FUNCTION) {
-                        inlineTranslationPaths.push({
-                            localName: name.local,
-                            path,
-                            originalName: name.original,
-                        });
-                    }
-                    else if (name.original === TRANSLATION_COMPONENT) {
-                        translationComponentPaths.push({
-                            localName: name.local,
-                            path,
-                            originalName: name.original,
-                        });
-                    }
-                    else {
-                        importAliases[name.local] = name.original;
-                    }
-                }
-            }
-        },
-        VariableDeclarator(path) {
-            // Check if the init is a require call
-            if (path.node.init?.type === 'CallExpression' &&
-                path.node.init.callee.type === 'Identifier' &&
-                path.node.init.callee.name === 'require') {
-                // Check if it's requiring our package
-                const args = path.node.init.arguments;
-                if (args.length === 1 &&
-                    args[0].type === 'StringLiteral' &&
-                    pkgs.some((pkg) => args[0].value.startsWith(pkg))) {
-                    const parentPath = path.parentPath;
-                    if (parentPath.isVariableDeclaration()) {
-                        const importName = extractImportName(parentPath.node, pkgs, GT_TRANSLATION_FUNCS);
-                        for (const name of importName) {
-                            if (name.original === INLINE_TRANSLATION_HOOK ||
-                                name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
-                                name.original === INLINE_MESSAGE_HOOK ||
-                                name.original === INLINE_MESSAGE_HOOK_ASYNC) {
-                                inlineTranslationPaths.push({
-                                    localName: name.local,
-                                    path: parentPath,
-                                    originalName: name.original,
-                                });
-                            }
-                            else if (name.original === TRANSLATION_COMPONENT) {
-                                translationComponentPaths.push({
-                                    localName: name.local,
-                                    path: parentPath,
-                                    originalName: name.original,
-                                });
-                            }
-                            else {
-                                importAliases[name.local] = name.original;
-                            }
-                        }
-                    }
-                }
-            }
-        },
-    });
-    return {
-        importAliases,
-        inlineTranslationPaths,
-        translationComponentPaths,
-    };
-}

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

@@ -1,7 +0,0 @@
-import * as t from '@babel/types';
-/**
- * Given an expression, return true if it is a number literal
- * @param expr - The expression to check
- * @returns True if the expression is a number literal, false otherwise
- */
-export declare function isNumberLiteral(expr: t.Expression): boolean;

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

@@ -1,13 +0,0 @@
-import * as t from '@babel/types';
-/**
- * Given an expression, return true if it is a number literal
- * @param expr - The expression to check
- * @returns True if the expression is a number literal, false otherwise
- */
-export function isNumberLiteral(expr) {
-    if (t.isUnaryExpression(expr)) {
-        return (isNumberLiteral(expr.argument) &&
-            (expr.operator === '-' || expr.operator === '+'));
-    }
-    return t.isNumericLiteral(expr);
-}

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

@@ -1,9 +0,0 @@
-import { JsxChildren } from 'generaltranslation/types';
-import { MultipliedTreeNode } from './types.js';
-/**
- * Add GT Identifier and minify the tree (recreates addGTIdentifier and writeChildrenAsObjects)
- * @param tree - The tree to add GT identifiers to
- * @param startingIndex - The starting index for GT IDs
- * @returns The tree with GT identifiers added
- */
-export default function addGTIdentifierToSyntaxTree(tree: MultipliedTreeNode, startingIndex?: number): JsxChildren;

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

@@ -1,135 +0,0 @@
-import { HTML_CONTENT_PROPS, } from 'generaltranslation/types';
-import { defaultVariableNames, getVariableName, minifyVariableType, } from '../../../utils/getVariableName.js';
-import { isAcceptedPluralForm } from 'generaltranslation/internal';
-/**
- * Construct the data-_gt prop
- * @param type - The type of the element
- * @param props - The props of the element
- * @param id - The id of the element
- * @returns The data-_gt prop
- */
-function constructGTProp(type, props, id) {
-    // Add translatable HTML content props
-    const generaltranslation = Object.entries(HTML_CONTENT_PROPS).reduce((acc, [minifiedName, fullName]) => {
-        if (props[fullName]) {
-            acc[minifiedName] = props[fullName];
-        }
-        return acc;
-    }, {});
-    // Plural
-    if (type === 'Plural') {
-        const pluralBranches = Object.entries(props).reduce((acc, [branchName, branch]) => {
-            if (isAcceptedPluralForm(branchName)) {
-                acc[branchName] = addGTIdentifierToSyntaxTree(branch, id);
-            }
-            return acc;
-        }, {});
-        // Add plural branches to the generaltranslation
-        if (Object.keys(pluralBranches).length) {
-            generaltranslation.t = 'p';
-            generaltranslation.b = pluralBranches;
-        }
-        // Branch
-    }
-    else if (type === 'Branch') {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
-        const { children, branch, ...branches } = props;
-        const resultBranches = Object.entries(branches).reduce((acc, [branchName, branch]) => {
-            acc[branchName] = addGTIdentifierToSyntaxTree(branch, id);
-            return acc;
-        }, {});
-        // Add branches to the generaltranslation
-        if (Object.keys(resultBranches).length) {
-            generaltranslation.t = 'b';
-            generaltranslation.b = resultBranches;
-        }
-    }
-    return Object.keys(generaltranslation).length
-        ? generaltranslation
-        : undefined;
-}
-/**
- * Add GT Identifier and minify the tree (recreates addGTIdentifier and writeChildrenAsObjects)
- * @param tree - The tree to add GT identifiers to
- * @param startingIndex - The starting index for GT IDs
- * @returns The tree with GT identifiers added
- */
-export default function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
-    // Edge case: boolean or null, just return the tree
-    if (typeof tree === 'boolean' || tree === null) {
-        return tree;
-    }
-    // Object to keep track of the current index for GT IDs
-    const indexObject = { index: startingIndex };
-    /**
-     * Handle a single child
-     * @param child - The child to handle
-     * @returns The handled child
-     */
-    const handleSingleChild = (child) => {
-        // Handle JSX elements
-        if (child && typeof child === 'object') {
-            let { type } = child;
-            const { props } = child;
-            indexObject.index += 1;
-            // Handle fragments
-            if (type === 'React.Fragment') {
-                type = '';
-            }
-            // Variables
-            if (Object.keys(defaultVariableNames).includes(type)) {
-                const variableType = minifyVariableType(type);
-                const variableName = getVariableName(props, type, indexObject.index);
-                return {
-                    i: indexObject.index,
-                    k: variableName,
-                    v: variableType,
-                };
-            }
-            // Construct the data-_gt prop
-            const generaltranslation = constructGTProp(type, (props || {}), indexObject.index);
-            // Save current index and recurse
-            const currentIndex = indexObject.index;
-            const children = handleChildren(props?.children === undefined ? null : props?.children);
-            // Enforce boolean rendering behavior
-            // <T>{true}</T> -> true <- this is a boolean value, not a string
-            // <T>{false}</T> -> nothing
-            let includeChildren = true;
-            if (typeof children === 'boolean') {
-                // So, technically JsxChildren do include boolean values, but the type is incorrect
-                includeChildren = children !== false;
-            }
-            // Return the result
-            return {
-                t: type || `C${currentIndex}`,
-                i: currentIndex,
-                ...(includeChildren && { c: children }),
-                ...(generaltranslation && { d: generaltranslation }),
-            };
-        }
-        if (typeof child === 'number') {
-            return child.toString();
-        }
-        return child;
-    };
-    /**
-     * Handle children
-     * @param children - The children to handle
-     * @returns The handled children
-     */
-    const handleChildren = (children) => {
-        return Array.isArray(children)
-            ? children.map(handleSingleChild).filter((child) => {
-                // Enforce boolean rendering behavior
-                // <T>{true}{false}{null}</T> -> []
-                if (typeof child === 'boolean' ||
-                    child === null ||
-                    child === undefined) {
-                    return false;
-                }
-                return true;
-            })
-            : handleSingleChild(children);
-    };
-    return handleChildren(tree);
-}

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

@@ -1,6 +0,0 @@
-import { JsxTree, MultiplicationNode, WhitespaceJsxTreeResult, WhitespaceMultiplicationNode } from './types.js';
-export declare function trimJsxStringChild(child: string): string;
-export declare function handleChildrenWhitespace(currentTree: MultiplicationNode['branches'], parentNodeType: 'multiplication'): (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
-export declare function handleChildrenWhitespace(currentTree: MultiplicationNode['branches'], parentNodeType?: 'element' | 'expression' | undefined): WhitespaceJsxTreeResult | WhitespaceMultiplicationNode | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];
-export declare function handleChildrenWhitespace(currentTree: MultiplicationNode | JsxTree, parentNodeType?: 'multiplication' | 'element' | 'expression' | undefined): null | WhitespaceJsxTreeResult | WhitespaceMultiplicationNode;
-export declare function handleChildrenWhitespace(currentTree: JsxTree | JsxTree[]): null | WhitespaceJsxTreeResult | WhitespaceJsxTreeResult[];

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

@@ -1,197 +0,0 @@
-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':
-                    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

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

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

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

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

@@ -1,33 +0,0 @@
-import { Updates } from '../../../../types/index.js';
-import { ParsingConfigOptions } from '../../../../types/parsing.js';
-import traverseModule from '@babel/traverse';
-import { GTLibrary } from '../../../../types/libraries.js';
-/**
- * Immutable configuration options for parsing.
- */
-type ConfigOptions = {
-    parsingOptions: ParsingConfigOptions;
-    importAliases: Record<string, string>;
-    pkgs: GTLibrary[];
-    file: string;
-};
-/**
- * Collectors for errors, warnings, and unwrapped expressions.
- */
-type OutputCollector = {
-    errors: string[];
-    warnings: Set<string>;
-    unwrappedExpressions: string[];
-};
-/**
- * Entry point for JSX parsing
- */
-export declare function parseTranslationComponent({ originalName, localName, path, updates, config, output, }: {
-    originalName: string;
-    localName: string;
-    path: traverseModule.NodePath<traverseModule.Node>;
-    updates: Updates;
-    config: ConfigOptions;
-    output: OutputCollector;
-}): void;
-export {};