gtx-cli 2.6.31 → 2.7.0

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleLiteralTranslationCall.js

@@ -1,31 +0,0 @@
-import { isValidIcu } from '../../../evaluateJsx.js';
-import { warnInvalidIcuSync } from '../../../../../console/index.js';
-/**
- * For the processTranslationCall function, this function handles the case where a string literal or template literal is used.
- * @param arg - The argument to parse
- * @param metadata - The metadata to use
- * @param config - The configuration to use
- * @param output - The output to use
- * @param index - The index of the argument
- */
-export function handleLiteralTranslationCall({ arg, metadata, config, output, index, }) {
-    // ignore dynamic content flag is triggered, check strings are valid ICU
-    const source = arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;
-    // Validate is ICU
-    if (!config.ignoreInvalidIcu) {
-        const { isValid, error } = isValidIcu(source);
-        if (!isValid) {
-            output.warnings.add(warnInvalidIcuSync(config.file, source, error ?? 'Unknown error', `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-            return;
-        }
-    }
-    output.updates.push({
-        dataFormat: 'ICU',
-        source,
-        metadata: {
-            ...metadata,
-            // Add the index if an id and index is provided (for handling when registering an array of strings)
-            ...(metadata.id && index != null && { id: `${metadata.id}.${index}` }),
-        },
-    });
-}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleStaticTranslationCall.d.ts

@@ -1,22 +0,0 @@
-import { NodePath } from '@babel/traverse';
-import * as t from '@babel/types';
-import { ParsingConfig } from '../types.js';
-import { ParsingOutput } from '../types.js';
-import { InlineMetadata } from './extractStringEntryMetadata.js';
-/**
- * For the processTranslationCall function, this function handles the case where a string with declareStatic is used.
- * @param arg - The argument to parse
- * @param metadata - The metadata to use
- * @param tPath - The path to the argument
- * @param config - The configuration to use
- * @param output - The output to use
- * @param index - Current index in array of strings being extracted
- */
-export declare function handleStaticTranslationCall({ arg, metadata, tPath, config, output, index, }: {
-    arg: t.Expression;
-    metadata: InlineMetadata;
-    tPath: NodePath;
-    config: ParsingConfig;
-    output: ParsingOutput;
-    index?: number;
-}): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleStaticTranslationCall.js

@@ -1,51 +0,0 @@
-import { handleStaticExpression } from '../../parseDeclareStatic.js';
-import { nodeToStrings } from '../../parseString.js';
-import { indexVars } from 'generaltranslation/internal';
-import { isValidIcu } from '../../../evaluateJsx.js';
-import { warnInvalidIcuSync, warnNonStringSync, } from '../../../../../console/index.js';
-import generateModule from '@babel/generator';
-import { randomUUID } from 'node:crypto';
-// Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
-/**
- * For the processTranslationCall function, this function handles the case where a string with declareStatic is used.
- * @param arg - The argument to parse
- * @param metadata - The metadata to use
- * @param tPath - The path to the argument
- * @param config - The configuration to use
- * @param output - The output to use
- * @param index - Current index in array of strings being extracted
- */
-export function handleStaticTranslationCall({ arg, metadata, tPath, config, output, index, }) {
-    // parse static expression
-    const result = handleStaticExpression(arg, tPath, config.file, config.parsingOptions, output.errors);
-    // Nothing returned, push error
-    if (!result) {
-        output.errors.push(warnNonStringSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-        return;
-    }
-    // validate ICU
-    const strings = nodeToStrings(result).map(indexVars);
-    if (!config.ignoreInvalidIcu) {
-        for (const string of strings) {
-            const { isValid, error } = isValidIcu(string);
-            if (!isValid) {
-                output.warnings.add(warnInvalidIcuSync(config.file, string, error ?? 'Unknown error', `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-                return;
-            }
-        }
-    }
-    const temporaryStaticId = `static-temp-id-${randomUUID()}`;
-    for (const string of strings) {
-        output.updates.push({
-            dataFormat: 'ICU',
-            source: string,
-            metadata: {
-                ...metadata,
-                // Add the index if an id and index is provided (for handling when registering an array of strings)
-                ...(metadata.id && index != null && { id: `${metadata.id}.${index}` }),
-                staticId: temporaryStaticId,
-            },
-        });
-    }
-}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/index.d.ts

@@ -1,18 +0,0 @@
-import { NodePath } from '@babel/traverse';
-import { ParsingConfig } from '../types.js';
-import { ParsingOutput } from '../types.js';
-/**
- * Processes a single translation function call (e.g., t('hello world', { id: 'greeting' })).
- * Extracts the translatable string content and metadata, then adds it to the updates array.
- *
- * Handles:
- * - String literals: t('hello')
- * - Template literals without expressions: t(`hello`)
- * - Metadata extraction from options object
- * - Error reporting for non-static expressions and template literals with expressions
- *
- * @param tPath - The path to the translation call
- * @param config - The configuration to use
- * @param output - The output to use
- */
-export declare function processTranslationCall(tPath: NodePath, config: ParsingConfig, output: ParsingOutput): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/index.js

@@ -1,39 +0,0 @@
-import { routeTranslationCall } from './routeTranslationCall.js';
-import { extractStringEntryMetadata } from './extractStringEntryMetadata.js';
-/**
- * Processes a single translation function call (e.g., t('hello world', { id: 'greeting' })).
- * Extracts the translatable string content and metadata, then adds it to the updates array.
- *
- * Handles:
- * - String literals: t('hello')
- * - Template literals without expressions: t(`hello`)
- * - Metadata extraction from options object
- * - Error reporting for non-static expressions and template literals with expressions
- *
- * @param tPath - The path to the translation call
- * @param config - The configuration to use
- * @param output - The output to use
- */
-export function processTranslationCall(tPath, config, output) {
-    if (tPath.parent.type !== 'CallExpression' ||
-        tPath.parent.arguments.length === 0) {
-        return;
-    }
-    // Get arg and options
-    const arg = tPath.parent.arguments[0];
-    const options = tPath.parent.arguments.at(1);
-    // get metadata and id from options
-    const metadata = extractStringEntryMetadata({
-        options,
-        output,
-        config,
-    });
-    // Route tx call to appropriate handler
-    routeTranslationCall({
-        tPath,
-        config,
-        output,
-        arg,
-        metadata,
-    });
-}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/routeTranslationCall.d.ts

@@ -1,24 +0,0 @@
-import * as t from '@babel/types';
-import { ParsingConfig } from '../types.js';
-import { ParsingOutput } from '../types.js';
-import { NodePath } from '@babel/traverse';
-import { InlineMetadata } from './extractStringEntryMetadata.js';
-/**
- * Helper function for processTranslationCall
- * Given arg and options, maps to appropriate translation call handler
- * @param tPath - The path to the translation call
- * @param config - The configuration to use
- * @param output - The output to use
- * @param arg - The argument to parse
- * @param metadata - The metadata to use
- * @param index - The index of the argument
- * @returns void
- */
-export declare function routeTranslationCall({ tPath, config, output, arg, metadata, index, }: {
-    tPath: NodePath;
-    config: ParsingConfig;
-    output: ParsingOutput;
-    arg: t.CallExpression['arguments'][number];
-    metadata: InlineMetadata;
-    index?: number;
-}): void;

package/dist/react/jsx/utils/stringParsing/processTranslationCall/routeTranslationCall.js

@@ -1,68 +0,0 @@
-import { isStaticExpression } from '../../../evaluateJsx.js';
-import { handleStaticTranslationCall } from './handleStaticTranslationCall.js';
-import { handleLiteralTranslationCall } from './handleLiteralTranslationCall.js';
-import { handleInvalidTranslationCall } from './handleInvalidTranslationCall.js';
-import * as t from '@babel/types';
-/**
- * Helper function for processTranslationCall
- * Given arg and options, maps to appropriate translation call handler
- * @param tPath - The path to the translation call
- * @param config - The configuration to use
- * @param output - The output to use
- * @param arg - The argument to parse
- * @param metadata - The metadata to use
- * @param index - The index of the argument
- * @returns void
- */
-export function routeTranslationCall({ tPath, config, output, arg, metadata, index, }) {
-    if (t.isArrayExpression(arg) &&
-        index == null &&
-        !config.ignoreInlineListContent) {
-        // handle array translation call
-        for (let i = 0; i < arg.elements.length; i++) {
-            const element = arg.elements[i];
-            if (element == null)
-                continue;
-            routeTranslationCall({
-                tPath,
-                config,
-                output,
-                arg: element,
-                index: i,
-                metadata,
-            });
-        }
-    }
-    else if (!config.ignoreDynamicContent &&
-        t.isExpression(arg) &&
-        !isStaticExpression(arg).isStatic) {
-        // handle static translation call
-        handleStaticTranslationCall({
-            arg,
-            metadata,
-            tPath,
-            config,
-            output,
-            index,
-        });
-    }
-    else if (arg.type === 'StringLiteral' ||
-        (t.isTemplateLiteral(arg) && arg.expressions.length === 0)) {
-        // Handle string and template literals
-        handleLiteralTranslationCall({
-            arg,
-            metadata,
-            config,
-            output,
-            index,
-        });
-    }
-    else {
-        // error on invalid translation call
-        handleInvalidTranslationCall({
-            arg,
-            config,
-            output,
-        });
-    }
-}

package/dist/react/jsx/utils/stringParsing/types.d.ts

@@ -1,41 +0,0 @@
-import { ParsingConfigOptions } from '../../../../types/parsing.js';
-import { Updates } from '../../../../types/index.js';
-/**
- * Immutable configuration options for string parsing.
- */
-export type ParsingConfig = {
-    parsingOptions: ParsingConfigOptions;
-    file: string;
-    /**
-     * If true, ignores fields like $context, $id, etc. when extracting metadata from a string entry
-     */
-    ignoreInlineMetadata: boolean;
-    /**
-     * If true, dynamic content will not be treated as errors
-     */
-    ignoreDynamicContent: boolean;
-    /**
-     * If true, invalid ICU strings will not be treated as errors
-     */
-    ignoreInvalidIcu: boolean;
-    /**
-     * If true, will ignore registration of list content
-     * eg msg(['hello', 'world', 'foo', 'bar']) will not be registered
-     */
-    ignoreInlineListContent: boolean;
-};
-/**
- * Mutable state for tracking parsing progress.
- */
-export type ParsingState = {
-    visited: Set<string>;
-    importMap: Map<string, string>;
-};
-/**
- * Collectors for updates, errors, and warnings.
- */
-export type ParsingOutput = {
-    updates: Updates;
-    errors: string[];
-    warnings: Set<string>;
-};

package/dist/react/jsx/utils/stringParsing/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,14 +0,0 @@
-type StringNode = StringTextNode | StringSequenceNode | StringChoiceNode;
-type StringTextNode = {
-    type: 'text';
-    text: string;
-};
-type StringSequenceNode = {
-    type: 'sequence';
-    nodes: StringNode[];
-};
-type StringChoiceNode = {
-    type: 'choice';
-    nodes: StringNode[];
-};
-export type { StringNode, StringTextNode, StringSequenceNode, StringChoiceNode, };

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,7 +0,0 @@
-import { NodePath } from '@babel/traverse';
-import { Updates } from '../../../types/index.js';
-/**
- * Validate useGT() / await getGT() calls
- * 1. Validates that the call does not violate the rules of React (no hooks in async functions)
- */
-export declare function validateStringFunction(localImportName: string, path: NodePath, updates: Updates, errors: string[], file: string, originalImportName: string): void;

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

@@ -1,31 +0,0 @@
-import { warnAsyncUseGT, warnSyncGetGT } from '../../../console/index.js';
-import { INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, } from './constants.js';
-/**
- * Validate useGT() / await getGT() calls
- * 1. Validates that the call does not violate the rules of React (no hooks in async functions)
- */
-export function validateStringFunction(localImportName, path, updates, errors, file, originalImportName) {
-    // Get the root program node to traverse the entire file
-    const program = path.scope.getProgramParent().path;
-    program.traverse({
-        CallExpression(callPath) {
-            if (callPath.node.callee.type === 'Identifier' &&
-                callPath.node.callee.name === localImportName) {
-                // Check the function scope
-                const functionScope = callPath.getFunctionParent();
-                if (originalImportName === INLINE_TRANSLATION_HOOK) {
-                    // useGT should NOT be in an async function
-                    if (functionScope && functionScope.node.async) {
-                        errors.push(warnAsyncUseGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));
-                    }
-                }
-                else if (originalImportName === INLINE_TRANSLATION_HOOK_ASYNC) {
-                    // getGT should be in an async function
-                    if (!functionScope || !functionScope.node.async) {
-                        errors.push(warnSyncGetGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));
-                    }
-                }
-            }
-        },
-    });
-}

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

@@ -1,51 +0,0 @@
-import * as t from '@babel/types';
-import { ImportItem } from './utils/parseAst.js';
-/**
- * Recursively wraps a JSX element with a <T> component and unique id
- * @param node - The JSX element to wrap
- * @param updates - The updates array
- * @param errors - The errors array
- * @param file - The file name
- * @param options - Optional component names for T and Var
- */
-export interface WrapResult {
-    node: t.JSXElement | t.JSXFragment;
-    hasMeaningfulContent: boolean;
-    wrappedInT: boolean;
-}
-/**
- * Recursively traverse a JSX element and wrap variables with a <Var> component
- * @param node - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export declare function wrapJsxElement(node: t.JSXElement | t.JSXFragment, options: {
-    createIds: boolean;
-    TComponent?: string;
-    VarComponent?: string;
-    idPrefix: string;
-    idCount: number;
-    usedImports: ImportItem[];
-    modified: boolean;
-    warnings: string[];
-    file: string;
-}, isMeaningful: (node: t.Node) => boolean, mark: boolean): WrapResult;
-/**
- * Wraps a JSX element with a <T> component and unique id
- * @param rootNode - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export declare function handleJsxElement(rootNode: t.JSXElement | t.JSXFragment, options: {
-    createIds: boolean;
-    usedImports: ImportItem[];
-    TComponent?: string;
-    VarComponent?: string;
-    idPrefix: string;
-    idCount: number;
-    modified: boolean;
-    warnings: string[];
-    file: string;
-}, isMeaningful: (node: t.Node) => boolean): WrapResult;