gt 0.10.0 → 2.7.0

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

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

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

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

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

@@ -0,0 +1,138 @@
+import { HTML_CONTENT_PROPS, } from 'generaltranslation/types';
+import { defaultVariableNames, getVariableName, minifyVariableType, } from '../../../utils/getVariableName.js';
+import { isAcceptedPluralForm } from 'generaltranslation/internal';
+import { DATA_ATTR_PREFIX } from '../constants.js';
+/**
+ * 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, ...allBranches } = props;
+        // Filter out data-* attributes injected by build tools
+        const branches = Object.fromEntries(Object.entries(allBranches).filter(([key]) => !key.startsWith(DATA_ATTR_PREFIX)));
+        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

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

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

@@ -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,33 @@
+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 {};