gtx-cli 1.2.14 → 1.2.15

package/dist/next/parse/wrapContent.js

@@ -1,181 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = wrapContentNext;
-const node_fs_1 = __importDefault(require("node:fs"));
-const t = __importStar(require("@babel/types"));
-const parser_1 = require("@babel/parser");
-const traverse_1 = __importDefault(require("@babel/traverse"));
-const generator_1 = __importDefault(require("@babel/generator"));
-const findJsxFilepath_1 = require("../../fs/findJsxFilepath");
-const evaluateJsx_1 = require("../../react/jsx/evaluateJsx");
-const wrapJsx_1 = require("../../react/jsx/wrapJsx");
-const findFilepath_1 = require("../../fs/findFilepath");
-const utils_1 = require("../jsx/utils");
-const parseAst_1 = require("../../react/jsx/utils/parseAst");
-const IMPORT_MAP = {
-    T: { name: 'T', source: 'gt-next' },
-    Var: { name: 'Var', source: 'gt-next' },
-    GTT: { name: 'T', source: 'gt-next' },
-    GTVar: { name: 'Var', source: 'gt-next' },
-    GTProvider: { name: 'GTProvider', source: 'gt-next' },
-    getLocale: { name: 'getLocale', source: 'gt-next/server' },
-};
-/**
- * Wraps all JSX elements in the src directory with a <T> tag, with unique ids.
- * - Ignores pure strings
- *
- * @param options - The options object
- * @returns An object containing the updates and errors
- */
-async function wrapContentNext(options, pkg, errors, warnings) {
-    const srcDirectory = options.src || ['./'];
-    const files = srcDirectory.flatMap((dir) => (0, findJsxFilepath_1.getFiles)(dir));
-    const filesUpdated = [];
-    for (const file of files) {
-        const code = await node_fs_1.default.promises.readFile(file, 'utf8');
-        // Create relative path from src directory and remove extension
-        const relativePath = (0, findFilepath_1.getRelativePath)(file, srcDirectory[0]);
-        let ast;
-        try {
-            ast = (0, parser_1.parse)(code, {
-                sourceType: 'module',
-                plugins: ['jsx', 'typescript'],
-                tokens: true,
-                createParenthesizedExpressions: true,
-            });
-        }
-        catch (error) {
-            errors.push(`Error: Failed to parse ${file}: ${error}`);
-            continue;
-        }
-        let modified = false;
-        let usedImports = [];
-        let { importAlias, initialImports } = (0, parseAst_1.generateImportMap)(ast, pkg);
-        // If the file already has a T import, skip processing it
-        if (initialImports.includes(IMPORT_MAP.T.name)) {
-            continue;
-        }
-        let globalId = 0;
-        (0, traverse_1.default)(ast, {
-            JSXElement(path) {
-                if (pkg === 'gt-next' &&
-                    options.addGTProvider &&
-                    (0, utils_1.isHtmlElement)(path.node.openingElement)) {
-                    // Find the body element in the HTML children
-                    const bodyElement = path.node.children.find((child) => t.isJSXElement(child) && (0, utils_1.isBodyElement)(child.openingElement));
-                    if (!bodyElement) {
-                        warnings.push(`File ${file} has a <html> tag without a <body> tag. Skipping GTProvider insertion.`);
-                        return;
-                    }
-                    // Skip if body already has GTProvider
-                    if ((0, utils_1.hasGTProviderChild)(bodyElement)) {
-                        return;
-                    }
-                    // Handle lang attribute for html tag
-                    const langAttr = path.node.openingElement.attributes.find((attr) => t.isJSXAttribute(attr) &&
-                        t.isJSXIdentifier(attr.name) &&
-                        t.isStringLiteral(attr.value) &&
-                        attr.name.name === 'lang');
-                    if (langAttr) {
-                        (0, utils_1.makeParentFunctionAsync)(path);
-                        (0, utils_1.addDynamicLangAttribute)(path.node.openingElement);
-                        usedImports.push('getLocale');
-                    }
-                    // Wrap body children with GTProvider
-                    const bodyChildren = bodyElement.children;
-                    const gtProviderElement = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier('GTProvider'), [], false), t.jsxClosingElement(t.jsxIdentifier('GTProvider')), bodyChildren, false);
-                    bodyElement.children = [gtProviderElement];
-                    usedImports.push('GTProvider');
-                    modified = true;
-                    path.skip();
-                    return;
-                }
-                // Check if this JSX element has any JSX element ancestors
-                let currentPath = path;
-                if (t.isJSXElement(currentPath.parentPath?.node)) {
-                    // If we found a JSX parent, skip processing this node
-                    return;
-                }
-                // At this point, we're only processing top-level JSX elements
-                const opts = {
-                    ...importAlias,
-                    idPrefix: relativePath,
-                    idCount: globalId,
-                    usedImports,
-                    modified: false,
-                    createIds: !options.disableIds,
-                    warnings,
-                    file,
-                };
-                const wrapped = (0, wrapJsx_1.handleJsxElement)(path.node, opts, evaluateJsx_1.isMeaningful);
-                path.replaceWith(wrapped.node);
-                // Update global counters
-                modified = modified || opts.modified;
-                globalId = opts.idCount;
-            },
-        });
-        if (!modified)
-            continue;
-        let needsImport = usedImports.filter((imp) => !initialImports.includes(imp));
-        if (needsImport.length > 0) {
-            (0, parseAst_1.createImports)(ast, needsImport, IMPORT_MAP);
-        }
-        try {
-            const output = (0, generator_1.default)(ast, {
-                retainLines: true,
-                retainFunctionParens: true,
-                comments: true,
-                compact: 'auto',
-            }, code);
-            // Post-process the output to fix import spacing
-            let processedCode = output.code;
-            if (needsImport.length > 0) {
-                // Add newline after the comment only
-                processedCode = processedCode.replace(/((?:import\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*from|const\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*=\s*require)\s*['"]gt-(?:next|react)(?:\/server)?['"];?)/, '\n$1\n');
-            }
-            // Write the modified code back to the file
-            await node_fs_1.default.promises.writeFile(file, processedCode);
-            filesUpdated.push(file);
-        }
-        catch (error) {
-            errors.push(`Error: Failed to write ${file}: ${error}`);
-        }
-    }
-    return { filesUpdated };
-}

package/dist/react/config/createESBuildConfig.d.ts

@@ -1,2 +0,0 @@
-import esbuild from 'esbuild';
-export default function createESBuildConfig(config?: Record<string, any>): esbuild.BuildOptions;

package/dist/react/config/createESBuildConfig.js

@@ -1,125 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createESBuildConfig;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const console_1 = require("../../console/console");
-function createESBuildConfig(config = {}) {
-    const esbuildOptions = {
-        bundle: true,
-        format: 'cjs',
-        platform: 'node',
-        target: 'es2021',
-        loader: {
-            '.js': 'jsx',
-            '.ts': 'ts',
-            '.css': 'css', // Add CSS loader
-        },
-        sourcemap: 'inline',
-        external: ['server-only'],
-        define: {
-            React: 'global.React',
-        },
-        plugins: [],
-    };
-    // Add the custom plugin to handle 'server-only' imports
-    esbuildOptions.plugins.push({
-        name: 'ignore-server-only',
-        setup(build) {
-            build.onResolve({ filter: /^server-only$/ }, () => {
-                return {
-                    path: 'server-only',
-                    namespace: 'ignore-server-only',
-                };
-            });
-            build.onLoad({ filter: /^server-only$/, namespace: 'ignore-server-only' }, () => {
-                return {
-                    contents: 'module.exports = {};',
-                    loader: 'js',
-                };
-            });
-        },
-    });
-    // Add a plugin to handle CSS imports
-    esbuildOptions.plugins.push({
-        name: 'css-module',
-        setup(build) {
-            build.onResolve({ filter: /\.css$/ }, (args) => {
-                return {
-                    path: node_path_1.default.resolve(args.resolveDir, args.path),
-                    namespace: 'css-module',
-                };
-            });
-            build.onLoad({ filter: /\.css$/, namespace: 'css-module' }, async (args) => {
-                const css = await node_fs_1.default.promises.readFile(args.path, 'utf8');
-                const contents = `
-                    const style = document.createElement('style');
-                    style.textContent = ${JSON.stringify(css)};
-                    document.head.appendChild(style);
-                `;
-                return { contents, loader: 'js' };
-            });
-        },
-    });
-    if (config.compilerOptions) {
-        if (config.compilerOptions.paths) {
-            const aliases = {};
-            const resolvedPaths = [];
-            for (const [key, value] of Object.entries(config.compilerOptions.paths)) {
-                if (Array.isArray(value) && typeof value[0] === 'string') {
-                    const resolvedPath = node_path_1.default.resolve(process.cwd(), value[0].replace('/*', ''));
-                    aliases[key.replace('/*', '')] = resolvedPath;
-                    resolvedPaths.push([key, resolvedPath]);
-                }
-            }
-            if (resolvedPaths.length) {
-                (0, console_1.displayResolvedPaths)(resolvedPaths);
-            }
-            esbuildOptions.plugins = esbuildOptions.plugins || [];
-            esbuildOptions.plugins.push({
-                name: 'alias',
-                setup(build) {
-                    build.onResolve({ filter: /.*/ }, (args) => {
-                        for (const [aliasKey, aliasPath] of Object.entries(aliases)) {
-                            if (args.path.startsWith(`${aliasKey}/`)) {
-                                const resolvedPath = node_path_1.default.resolve(aliasPath, args.path.slice(aliasKey.length + 1));
-                                const extensions = ['.js', '.ts', '.css']; // Add .css to extensions
-                                function resolveWithExtensions(basePath) {
-                                    for (const ext of extensions) {
-                                        const fullPath = `${basePath}${ext}`;
-                                        try {
-                                            const realPath = node_fs_1.default.realpathSync(fullPath);
-                                            return realPath;
-                                        }
-                                        catch (_) {
-                                            continue;
-                                        }
-                                    }
-                                    return null;
-                                }
-                                try {
-                                    const realPath = node_fs_1.default.realpathSync(resolvedPath);
-                                    return { path: realPath };
-                                }
-                                catch (err) {
-                                    const hasExtension = extensions.some((ext) => resolvedPath.endsWith(ext));
-                                    if (!hasExtension) {
-                                        const resolvedWithExt = resolveWithExtensions(resolvedPath);
-                                        if (resolvedWithExt) {
-                                            return { path: resolvedWithExt };
-                                        }
-                                    }
-                                    throw new Error(`Unable to resolve path: ${resolvedPath}`);
-                                }
-                            }
-                        }
-                    });
-                },
-            });
-        }
-    }
-    return esbuildOptions;
-}

package/dist/react/data-_gt/addGTIdentifierToSyntaxTree.d.ts

@@ -1 +0,0 @@
-export default function addGTIdentifierToSyntaxTree(tree: any, startingIndex?: number): any;

package/dist/react/data-_gt/addGTIdentifierToSyntaxTree.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addGTIdentifierToSyntaxTree;
-const getVariableName_1 = require("../utils/getVariableName");
-const internal_1 = require("generaltranslation/internal");
-// recreates addGTIdentifier and writeChildrenAsObjects
-function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
-    // Object to keep track of the current index for GT IDs
-    let indexObject = { index: startingIndex };
-    const handleSingleChild = (child) => {
-        if (child && typeof child === 'object') {
-            const { type, props } = child;
-            indexObject.index += 1;
-            let generaltranslation = { id: indexObject.index };
-            if (type === 'Var') {
-                return {
-                    variable: 'variable',
-                    id: indexObject.index,
-                    key: (0, getVariableName_1.getVariableName)({ ...props, 'data-_gt': generaltranslation }, 'variable'),
-                };
-            }
-            else if (type === 'Num') {
-                return {
-                    variable: 'number',
-                    id: indexObject.index,
-                    key: (0, getVariableName_1.getVariableName)({ ...props, 'data-_gt': generaltranslation }, 'number'),
-                };
-            }
-            else if (type === 'Currency') {
-                return {
-                    variable: 'currency',
-                    id: indexObject.index,
-                    key: (0, getVariableName_1.getVariableName)({ ...props, 'data-_gt': generaltranslation }, 'currency'),
-                };
-            }
-            else if (type === 'DateTime') {
-                return {
-                    variable: 'datetime',
-                    id: indexObject.index,
-                    key: (0, getVariableName_1.getVariableName)({ ...props, 'data-_gt': generaltranslation }, 'datetime'),
-                };
-            }
-            else if (type === "" || type === "React.Fragment") {
-                generaltranslation.transformation = 'fragment';
-            }
-            if (type === 'Plural') {
-                generaltranslation.transformation = 'plural';
-                const pluralBranches = Object.entries(props).reduce((acc, [branchName, branch]) => {
-                    if ((0, internal_1.isAcceptedPluralForm)(branchName)) {
-                        acc[branchName] =
-                            addGTIdentifierToSyntaxTree(branch, indexObject.index);
-                    }
-                    return acc;
-                }, {});
-                if (Object.keys(pluralBranches).length)
-                    generaltranslation.branches = pluralBranches;
-            }
-            else if (type === 'Branch') {
-                generaltranslation.transformation = 'branch';
-                const { children, branch, ...branches } = props;
-                const resultBranches = Object.entries(branches).reduce((acc, [branchName, branch]) => {
-                    acc[branchName] =
-                        addGTIdentifierToSyntaxTree(branch, indexObject.index);
-                    return acc;
-                }, {});
-                if (Object.keys(resultBranches).length)
-                    generaltranslation.branches = resultBranches;
-            }
-            return {
-                type: type || `C${generaltranslation.id}`,
-                props: {
-                    'data-_gt': generaltranslation,
-                    ...(typeof props.children !== 'undefined' && {
-                        children: handleChildren(props.children),
-                    }),
-                },
-            };
-        }
-        return child.toString();
-    };
-    const handleChildren = (children) => {
-        return Array.isArray(children)
-            ? children.map(handleSingleChild)
-            : handleSingleChild(children);
-    };
-    return handleChildren(tree);
-}

package/dist/react/jsx/evaluateJsx.d.ts

@@ -1,17 +0,0 @@
-import * as t from '@babel/types';
-/**
- * Checks if a node is meaningful. Does not recurse into children.
- * @param node - The node to check
- * @returns Whether the node is meaningful
- */
-export declare function isMeaningful(node: t.Node): boolean;
-/**
- * Checks if an expression is static (does not contain any variables which could change at runtime).
- * @param expr - The expression to check
- * @returns An object containing the result of the static check
- */
-export declare function isStaticExpression(expr: t.Expression | t.JSXEmptyExpression): {
-    isStatic: boolean;
-    value?: string;
-};
-export declare function isStaticValue(expr: t.Expression | t.JSXEmptyExpression): boolean;

package/dist/react/jsx/evaluateJsx.js

@@ -1,133 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMeaningful = isMeaningful;
-exports.isStaticExpression = isStaticExpression;
-exports.isStaticValue = isStaticValue;
-const t = __importStar(require("@babel/types"));
-const MEANINGFUL_REGEX = /[\p{L}\p{N}]/u;
-/**
- * Checks if a node is meaningful. Does not recurse into children.
- * @param node - The node to check
- * @returns Whether the node is meaningful
- */
-function isMeaningful(node) {
-    if (t.isStringLiteral(node) || t.isJSXText(node)) {
-        return MEANINGFUL_REGEX.test(node.value);
-    }
-    // Handle template literals without expressions
-    if (t.isTemplateLiteral(node) && node.expressions.length === 0) {
-        return MEANINGFUL_REGEX.test(node.quasis[0].value.raw);
-    }
-    if (t.isJSXExpressionContainer(node)) {
-        const value = isStaticExpression(node.expression);
-        if (value.isStatic && value.value) {
-            return MEANINGFUL_REGEX.test(value.value);
-        }
-    }
-    if (t.isBinaryExpression(node)) {
-        if (node.operator === '+') {
-            return isMeaningful(node.left) || isMeaningful(node.right);
-        }
-    }
-    return false;
-}
-/**
- * Checks if an expression is static (does not contain any variables which could change at runtime).
- * @param expr - The expression to check
- * @returns An object containing the result of the static check
- */
-function isStaticExpression(expr) {
-    // Handle empty expressions
-    if (t.isJSXEmptyExpression(expr)) {
-        return { isStatic: true, value: '' };
-    }
-    // Handle direct string literals
-    if (t.isStringLiteral(expr)) {
-        return { isStatic: true, value: expr.value };
-    }
-    // Handle template literals without expressions
-    if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) {
-        return { isStatic: true, value: expr.quasis[0].value.raw };
-    }
-    // Handle binary expressions (string concatenation)
-    if (t.isBinaryExpression(expr)) {
-        // Only handle string concatenation
-        if (expr.operator !== '+') {
-            return { isStatic: false };
-        }
-        // Type guard to ensure we only process Expression types
-        if (t.isExpression(expr.left) && t.isExpression(expr.right)) {
-            const left = isStaticExpression(expr.left);
-            const right = isStaticExpression(expr.right);
-            if (left.isStatic &&
-                right.isStatic &&
-                left.value !== undefined &&
-                right.value !== undefined) {
-                return { isStatic: true, value: left.value + right.value };
-            }
-        }
-    }
-    // Handle parenthesized expressions
-    if (t.isParenthesizedExpression(expr)) {
-        return isStaticExpression(expr.expression);
-    }
-    // Handle numeric literals by converting them to strings
-    if (t.isNumericLiteral(expr)) {
-        return { isStatic: true, value: String(expr.value) };
-    }
-    // Handle boolean literals by converting them to strings
-    if (t.isBooleanLiteral(expr)) {
-        return { isStatic: true, value: String(expr.value) };
-    }
-    // Handle null literal
-    if (t.isNullLiteral(expr)) {
-        return { isStatic: true, value: 'null' };
-    }
-    // Not a static expression
-    return { isStatic: false };
-}
-function isStaticValue(expr) {
-    if (t.isStringLiteral(expr)) {
-        return true;
-    }
-    if (t.isNumericLiteral(expr)) {
-        return true;
-    }
-    if (t.isTemplateLiteral(expr)) {
-        return true;
-    }
-    return false;
-}

package/dist/react/jsx/parse/parseStringFunction.d.ts

@@ -1,12 +0,0 @@
-import { NodePath } from '@babel/traverse';
-import { Updates } from '../../../types';
-export declare const attributes: string[];
-/**
- * For the following example code:
- * const tx = useGT();
- * tx('string to translate', { id: 'exampleId', context: 'exampleContext' });
- *
- * This function will find all call expressions of useGT(), then find all call expressions
- * of the subsequent tx() calls, and append the content and metadata to the updates array.
- */
-export declare function parseStrings(importName: string, path: NodePath, updates: Updates, errors: string[], file: string): void;