gtx-cli 2.6.31 → 2.7.0

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

@@ -1,348 +0,0 @@
-import * as t from '@babel/types';
-import { MSG_REGISTRATION_FUNCTION, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } from './constants.js';
-import { warnAsyncUseGT, warnSyncGetGT } from '../../../console/index.js';
-import traverseModule from '@babel/traverse';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
-import fs from 'node:fs';
-import { parse } from '@babel/parser';
-import { resolveImportPath } from './resolveImportPath.js';
-import { buildImportMap } from './buildImportMap.js';
-import { processTranslationCall } from './stringParsing/processTranslationCall/index.js';
-/**
- * Cache for resolved import paths to avoid redundant I/O operations.
- * Key: `${currentFile}::${importPath}`
- * Value: resolved absolute path or null
- */
-const resolveImportPathCache = new Map();
-/**
- * Cache for processed functions to avoid re-parsing the same files.
- * Key: `${filePath}::${functionName}::${argIndex}`
- * Value: boolean indicating whether the function was found and processed
- */
-const processFunctionCache = new Map();
-/**
- * Clears all caches. Useful for testing or when file system changes.
- */
-export function clearParsingCaches() {
-    resolveImportPathCache.clear();
-    processFunctionCache.clear();
-}
-/**
- * Extracts the parameter name from a function parameter node, handling TypeScript annotations and default values.
- */
-function extractParameterName(param) {
-    if (t.isIdentifier(param)) {
-        return param.name;
-    }
-    // Handle parameters with default values: (gt = () => {})
-    if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
-        return param.left.name;
-    }
-    return null;
-}
-/**
- * Recursively resolves variable assignments to find all aliases of a translation callback parameter.
- * Handles cases like: const t = translate; const a = translate; const b = a; const c = b;
- *
- * @param scope The scope to search within
- * @param variableName The variable name to resolve
- * @param visited Set to track already visited variables to prevent infinite loops
- * @returns Array of all variable names that reference the original translation callback
- */
-export function resolveVariableAliases(scope, variableName, visited = new Set()) {
-    if (visited.has(variableName)) {
-        return []; // Prevent infinite loops
-    }
-    visited.add(variableName);
-    const aliases = [variableName];
-    const binding = scope.bindings[variableName];
-    if (binding) {
-        // Look for variable declarations that assign this variable to another name
-        // Example: const t = translate; or const a = t;
-        for (const [otherVarName, otherBinding] of Object.entries(scope.bindings)) {
-            if (otherVarName === variableName || visited.has(otherVarName))
-                continue;
-            const otherBindingTyped = otherBinding;
-            if (otherBindingTyped.path &&
-                otherBindingTyped.path.isVariableDeclarator() &&
-                otherBindingTyped.path.node.init &&
-                t.isIdentifier(otherBindingTyped.path.node.init) &&
-                otherBindingTyped.path.node.init.name === variableName) {
-                // Found an alias: const otherVarName = variableName;
-                const nestedAliases = resolveVariableAliases(scope, otherVarName, visited);
-                aliases.push(...nestedAliases);
-            }
-        }
-    }
-    return aliases;
-}
-/**
- * Handles how translation callbacks are used within code.
- * This covers both direct translation calls (t('hello')) and prop drilling
- * where the translation callback is passed to other functions (getData(t)).
- */
-function handleFunctionCall(tPath, config, state, output) {
-    if (tPath.parent.type === 'CallExpression' &&
-        tPath.parent.callee === tPath.node) {
-        // Direct translation call: t('hello')
-        processTranslationCall(tPath, config, output);
-    }
-    else if (tPath.parent.type === 'CallExpression' &&
-        t.isExpression(tPath.node) &&
-        tPath.parent.arguments.includes(tPath.node)) {
-        // Parameter passed to another function: getData(t)
-        const argIndex = tPath.parent.arguments.indexOf(tPath.node);
-        const callee = tPath.parent.callee;
-        if (t.isIdentifier(callee)) {
-            const calleeBinding = tPath.scope.getBinding(callee.name);
-            if (calleeBinding && calleeBinding.path.isFunction()) {
-                const functionPath = calleeBinding.path;
-                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, config, output);
-            }
-            // Handle arrow functions assigned to variables: const getData = (t) => {...}
-            else if (calleeBinding &&
-                calleeBinding.path.isVariableDeclarator() &&
-                calleeBinding.path.node.init &&
-                (t.isArrowFunctionExpression(calleeBinding.path.node.init) ||
-                    t.isFunctionExpression(calleeBinding.path.node.init))) {
-                const initPath = calleeBinding.path.get('init');
-                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, config, output);
-            }
-            // If not found locally, check if it's an imported function
-            else if (state.importMap.has(callee.name)) {
-                const importPath = state.importMap.get(callee.name);
-                const resolvedPath = resolveImportPath(config.file, importPath, config.parsingOptions, resolveImportPathCache);
-                if (resolvedPath) {
-                    processFunctionInFile(resolvedPath, callee.name, argIndex, config, state, output);
-                }
-            }
-        }
-    }
-}
-/**
- * Processes a user-defined function that receives a translation callback as a parameter.
- * Validates the function has enough parameters and traces how the translation callback
- * is used within that function's body.
- */
-function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, config, output) {
-    if (functionNode.params.length > argIndex) {
-        const param = functionNode.params[argIndex];
-        const paramName = extractParameterName(param);
-        if (paramName) {
-            findFunctionParameterUsage(functionPath, paramName, config, output);
-        }
-    }
-}
-/**
- * Finds all usages of a translation callback parameter within a user-defined function's scope.
- * Processes both direct translation calls and cases where the translation callback is passed
- * to other functions (prop drilling).
- *
- * Example: In function getInfo(t) { return t('hello'); }, this finds the t('hello') call.
- * Example: In function getData(t) { return getFooter(t); }, this finds and traces into getFooter.
- */
-function findFunctionParameterUsage(functionPath, parameterName, config, output) {
-    // Look for the function body and find all usages of the parameter
-    if (functionPath.isFunction()) {
-        const functionScope = functionPath.scope;
-        // Resolve all aliases of the translation callback parameter
-        // Example: translate -> [translate, t, a, b] for const t = translate; const a = t; const b = a;
-        const allParameterNames = resolveVariableAliases(functionScope, parameterName);
-        // Build import map for this function's scope to handle cross-file calls
-        const programPath = functionPath.scope.getProgramParent().path;
-        const importMap = buildImportMap(programPath);
-        // Process references for all parameter names and their aliases
-        allParameterNames.forEach((name) => {
-            const binding = functionScope.bindings[name];
-            if (binding) {
-                binding.referencePaths.forEach((refPath) => {
-                    handleFunctionCall(refPath, config, { visited: new Set(), importMap }, output);
-                });
-            }
-        });
-    }
-}
-/**
- * Searches for a specific user-defined function in a file and analyzes how a translation callback
- * parameter (at argIndex position) is used within that function.
- *
- * Handles multiple function declaration patterns:
- * - function getInfo(t) { ... }
- * - export function getInfo(t) { ... }
- * - const getInfo = (t) => { ... }
- *
- * If the function is not found in the file, follows re-exports (export * from './other')
- */
-function processFunctionInFile(filePath, functionName, argIndex, config, state, output) {
-    // Check cache first to avoid redundant parsing
-    const cacheKey = `${filePath}::${functionName}::${argIndex}`;
-    if (processFunctionCache.has(cacheKey)) {
-        return;
-    }
-    // Prevent infinite loops from circular re-exports
-    if (state.visited.has(filePath)) {
-        return;
-    }
-    state.visited.add(filePath);
-    try {
-        const code = fs.readFileSync(filePath, 'utf8');
-        const ast = parse(code, {
-            sourceType: 'module',
-            plugins: ['jsx', 'typescript'],
-        });
-        let found = false;
-        const reExports = [];
-        traverse(ast, {
-            // Handle function declarations: function getInfo(t) { ... }
-            FunctionDeclaration(path) {
-                if (path.node.id?.name === functionName) {
-                    found = true;
-                    processFunctionIfMatches(functionName, argIndex, path.node, path, config, output);
-                }
-            },
-            // Handle variable declarations: const getInfo = (t) => { ... }
-            VariableDeclarator(path) {
-                if (t.isIdentifier(path.node.id) &&
-                    path.node.id.name === functionName &&
-                    path.node.init &&
-                    (t.isArrowFunctionExpression(path.node.init) ||
-                        t.isFunctionExpression(path.node.init))) {
-                    found = true;
-                    const initPath = path.get('init');
-                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, config, output);
-                }
-            },
-            // Collect re-exports: export * from './other'
-            ExportAllDeclaration(path) {
-                if (t.isStringLiteral(path.node.source)) {
-                    reExports.push(path.node.source.value);
-                }
-            },
-            // Collect named re-exports: export { foo } from './other'
-            ExportNamedDeclaration(path) {
-                if (path.node.source && t.isStringLiteral(path.node.source)) {
-                    // Check if this export includes our function
-                    const exportsFunction = path.node.specifiers.some((spec) => {
-                        if (t.isExportSpecifier(spec)) {
-                            const exportedName = t.isIdentifier(spec.exported)
-                                ? spec.exported.name
-                                : spec.exported.value;
-                            return exportedName === functionName;
-                        }
-                        return false;
-                    });
-                    if (exportsFunction) {
-                        reExports.push(path.node.source.value);
-                    }
-                }
-            },
-        });
-        // If function not found, follow re-exports
-        if (!found && reExports.length > 0) {
-            for (const reExportPath of reExports) {
-                const resolvedPath = resolveImportPath(filePath, reExportPath, config.parsingOptions, resolveImportPathCache);
-                if (resolvedPath) {
-                    processFunctionInFile(resolvedPath, functionName, argIndex, config, state, output);
-                }
-            }
-        }
-        // Mark this function search as processed in the cache
-        processFunctionCache.set(cacheKey, found);
-    }
-    catch {
-        // Silently skip files that can't be parsed or accessed
-        // Still mark as processed to avoid retrying failed parses
-        processFunctionCache.set(cacheKey, false);
-    }
-}
-/**
- * Main entry point for parsing translation strings from useGT() and getGT() calls.
- *
- * Supports complex patterns including:
- * 1. Direct calls: const t = useGT(); t('hello');
- * 2. Translation callback prop drilling: const t = useGT(); getInfo(t); where getInfo uses t() internally
- * 3. Cross-file function calls: imported functions that receive the translation callback as a parameter
- *
- * Example flow:
- * - const t = useGT();
- * - const { home } = getInfo(t); // getInfo is imported from './constants'
- * - This will parse constants.ts to find translation calls within getInfo function
- */
-export function parseStrings(importName, originalName, path, config, output) {
-    // First, collect all imports in this file to track cross-file function calls
-    const importMap = buildImportMap(path.scope.getProgramParent().path);
-    const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
-    for (const refPath of referencePaths) {
-        // Handle msg() calls directly without variable assignment
-        if (originalName === MSG_REGISTRATION_FUNCTION) {
-            const msgConfig = {
-                parsingOptions: config.parsingOptions,
-                file: config.file,
-                ignoreInlineMetadata: false,
-                ignoreDynamicContent: false,
-                ignoreInvalidIcu: false,
-                ignoreInlineListContent: false,
-            };
-            // Check if this is a direct call to msg('string')
-            if (refPath.parent.type === 'CallExpression' &&
-                refPath.parent.callee === refPath.node) {
-                processTranslationCall(refPath, msgConfig, output);
-            }
-            continue;
-        }
-        // Handle useGT(), getGT(), useMessages(), and getMessages() calls that need variable assignment
-        const callExpr = refPath.findParent((p) => p.isCallExpression());
-        if (callExpr) {
-            // Get the parent, handling both await and non-await cases
-            const parentPath = callExpr.parentPath;
-            const parentFunction = refPath.getFunctionParent();
-            const asyncScope = parentFunction?.node.async;
-            if (asyncScope &&
-                (originalName === INLINE_TRANSLATION_HOOK ||
-                    originalName === INLINE_MESSAGE_HOOK)) {
-                output.errors.push(warnAsyncUseGT(config.file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
-                return;
-            }
-            else if (!asyncScope &&
-                (originalName === INLINE_TRANSLATION_HOOK_ASYNC ||
-                    originalName === INLINE_MESSAGE_HOOK_ASYNC)) {
-                output.errors.push(warnSyncGetGT(config.file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
-                return;
-            }
-            const isMessageHook = originalName === INLINE_MESSAGE_HOOK ||
-                originalName === INLINE_MESSAGE_HOOK_ASYNC;
-            const isInlineGT = originalName === INLINE_TRANSLATION_HOOK ||
-                originalName === INLINE_TRANSLATION_HOOK_ASYNC;
-            const hookConfig = {
-                parsingOptions: config.parsingOptions,
-                file: config.file,
-                ignoreInlineMetadata: isMessageHook,
-                ignoreDynamicContent: isMessageHook,
-                ignoreInvalidIcu: isMessageHook,
-                // TODO: when we add support for array content in gt function, this should just always be false
-                ignoreInlineListContent: isInlineGT,
-            };
-            const effectiveParent = parentPath?.node.type === 'AwaitExpression'
-                ? parentPath.parentPath
-                : parentPath;
-            if (effectiveParent &&
-                effectiveParent.node.type === 'VariableDeclarator' &&
-                effectiveParent.node.id.type === 'Identifier') {
-                const tFuncName = effectiveParent.node.id.name;
-                // Get the scope from the variable declaration
-                const variableScope = effectiveParent.scope;
-                // Resolve all aliases of the translation function
-                // Example: translate -> [translate, t, a, b] for const t = translate; const a = t; const b = a;
-                const allTranslationNames = resolveVariableAliases(variableScope, tFuncName);
-                // Process references for all translation function names and their aliases
-                allTranslationNames.forEach((name) => {
-                    const tReferencePaths = variableScope.bindings[name]?.referencePaths || [];
-                    for (const tPath of tReferencePaths) {
-                        handleFunctionCall(tPath, hookConfig, { visited: new Set(), importMap }, output);
-                    }
-                });
-            }
-        }
-    }
-}

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

@@ -1,11 +0,0 @@
-import { ParsingConfigOptions } from '../../../types/parsing.js';
-/**
- * Resolves import paths to absolute file paths using battle-tested libraries.
- * Handles relative paths, TypeScript paths, and node module resolution.
- *
- * Examples:
- * - './constants' -> '/full/path/to/constants.ts'
- * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
- * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
- */
-export declare function resolveImportPath(currentFile: string, importPath: string, parsingOptions: ParsingConfigOptions, resolveImportPathCache: Map<string, string | null>): string | null;

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

@@ -1,111 +0,0 @@
-import { createMatchPath, loadConfig } from 'tsconfig-paths';
-import fs from 'node:fs';
-import path from 'node:path';
-import resolve from 'resolve';
-import enhancedResolve from 'enhanced-resolve';
-const { ResolverFactory } = enhancedResolve;
-/**
- * Resolves import paths to absolute file paths using battle-tested libraries.
- * Handles relative paths, TypeScript paths, and node module resolution.
- *
- * Examples:
- * - './constants' -> '/full/path/to/constants.ts'
- * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
- * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
- */
-export function resolveImportPath(currentFile, importPath, parsingOptions, resolveImportPathCache) {
-    // Check cache first
-    const cacheKey = `${currentFile}::${importPath}`;
-    if (resolveImportPathCache.has(cacheKey)) {
-        return resolveImportPathCache.get(cacheKey);
-    }
-    const basedir = path.dirname(currentFile);
-    const extensions = ['.tsx', '.ts', '.jsx', '.js'];
-    const mainFields = ['module', 'main'];
-    let result = null;
-    // 1. Try tsconfig-paths resolution first (handles TypeScript path mapping)
-    const tsConfigResult = loadConfig(basedir);
-    if (tsConfigResult.resultType === 'success') {
-        const matchPath = createMatchPath(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, mainFields);
-        // First try without any extension
-        let tsResolved = matchPath(importPath);
-        if (tsResolved && fs.existsSync(tsResolved)) {
-            result = tsResolved;
-            resolveImportPathCache.set(cacheKey, result);
-            return result;
-        }
-        // Then try with each extension
-        for (const ext of extensions) {
-            tsResolved = matchPath(importPath + ext);
-            if (tsResolved && fs.existsSync(tsResolved)) {
-                result = tsResolved;
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            // Also try the resolved path with extension
-            tsResolved = matchPath(importPath);
-            if (tsResolved) {
-                const resolvedWithExt = tsResolved + ext;
-                if (fs.existsSync(resolvedWithExt)) {
-                    result = resolvedWithExt;
-                    resolveImportPathCache.set(cacheKey, result);
-                    return result;
-                }
-            }
-        }
-    }
-    // 2. Try enhanced-resolve (handles package.json exports field and modern resolution)
-    try {
-        const resolver = ResolverFactory.createResolver({
-            useSyncFileSystemCalls: true,
-            fileSystem: fs,
-            extensions,
-            // Include 'development' condition to resolve to source files in monorepos
-            conditionNames: parsingOptions.conditionNames, // defaults to ['browser', 'module', 'import', 'require', 'default']. See generateSettings.ts for more details
-            exportsFields: ['exports'],
-            mainFields,
-        });
-        const resolved = resolver.resolveSync({}, basedir, importPath);
-        if (resolved) {
-            result = resolved;
-            resolveImportPathCache.set(cacheKey, result);
-            return result;
-        }
-    }
-    catch {
-        // Fall through to next resolution strategy
-    }
-    // 3. Fallback to Node.js resolution (handles relative paths and node_modules)
-    try {
-        result = resolve.sync(importPath, { basedir, extensions });
-        resolveImportPathCache.set(cacheKey, result);
-        return result;
-    }
-    catch {
-        // If resolution fails, try to manually replace .js/.jsx with .ts/.tsx for source files
-        if (importPath.endsWith('.js')) {
-            const tsPath = importPath.replace(/\.js$/, '.ts');
-            try {
-                result = resolve.sync(tsPath, { basedir, extensions });
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        else if (importPath.endsWith('.jsx')) {
-            const tsxPath = importPath.replace(/\.jsx$/, '.tsx');
-            try {
-                result = resolve.sync(tsxPath, { basedir, extensions });
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        resolveImportPathCache.set(cacheKey, null);
-        return null;
-    }
-}

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

@@ -1,29 +0,0 @@
-import * as t from '@babel/types';
-import { ParsingConfig } from '../types.js';
-import { ParsingOutput } from '../types.js';
-/**
- * Metadata record type
- */
-export type InlineMetadata = {
-    maxChars?: number;
-    context?: string;
-    id?: string;
-    hash?: string;
-    filePaths?: string[];
-};
-/**
- * Extracts inline metadata from a string entry
- * @param metadata - The metadata record to inject the data into
- * @param entry - The string entry to extract the metadata from
- * @param output - The output to use
- * @param config - The configuration to use
- * @returns The inline metadata
- *
- * @note - this function does not automatically append the index to the id, this must be done manually in the caller.
- *
- */
-export declare function extractStringEntryMetadata({ options, output, config, }: {
-    options?: t.CallExpression['arguments'][number];
-    output: ParsingOutput;
-    config: ParsingConfig;
-}): InlineMetadata;

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

@@ -1,86 +0,0 @@
-import * as t from '@babel/types';
-import { isStaticExpression } from '../../../evaluateJsx.js';
-import { warnInvalidMaxCharsSync } from '../../../../../console/index.js';
-import { warnNonStaticExpressionSync } from '../../../../../console/index.js';
-import { GT_ATTRIBUTES_WITH_SUGAR } from '../../constants.js';
-import generateModule from '@babel/generator';
-import { mapAttributeName } from '../../mapAttributeName.js';
-import pathModule from 'node:path';
-import { isNumberLiteral } from '../../isNumberLiteral.js';
-// Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
-/**
- * Extracts inline metadata from a string entry
- * @param metadata - The metadata record to inject the data into
- * @param entry - The string entry to extract the metadata from
- * @param output - The output to use
- * @param config - The configuration to use
- * @returns The inline metadata
- *
- * @note - this function does not automatically append the index to the id, this must be done manually in the caller.
- *
- */
-export function extractStringEntryMetadata({ options, output, config, }) {
-    // extract filepath for entry
-    const relativeFilepath = pathModule.relative(process.cwd(), config.file);
-    // extract inline metadata
-    const inlineMetadata = extractInlineMetadata({
-        options,
-        output,
-        config,
-    });
-    return {
-        ...inlineMetadata,
-        filePaths: relativeFilepath ? [relativeFilepath] : undefined,
-    };
-}
-// ----- Helper Functions ----- //
-/**
- * Extracts inline metadata specified e.g. gt('Hello', { $context: 'greeting' })
- * @param options - The options to extract the metadata from
- * @param output - The output to use
- * @param config - The configuration to use
- * @param index - The index of the string entry
- * @returns The inline metadata
- */
-function extractInlineMetadata({ options, output, config, }) {
-    const metadata = {};
-    if (options && options.type === 'ObjectExpression') {
-        options.properties.forEach((prop) => {
-            if (prop.type === 'ObjectProperty' && prop.key.type === 'Identifier') {
-                const attribute = prop.key.name;
-                if (GT_ATTRIBUTES_WITH_SUGAR.includes(attribute) &&
-                    t.isExpression(prop.value)) {
-                    const result = isStaticExpression(prop.value);
-                    if (!result.isStatic) {
-                        output.errors.push(warnNonStaticExpressionSync(config.file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                    }
-                    if (result.isStatic &&
-                        result.value != null &&
-                        !config.ignoreInlineMetadata) {
-                        const mappedKey = mapAttributeName(attribute);
-                        if (mappedKey === 'maxChars') {
-                            // Handle maxChars attribute
-                            if ((typeof result.value === 'string' &&
-                                (isNaN(Number(result.value)) ||
-                                    !isNumberLiteral(prop.value))) ||
-                                !Number.isInteger(Number(result.value))) {
-                                output.errors.push(warnInvalidMaxCharsSync(config.file, generate(prop).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                            }
-                            else if (typeof result.value === 'string') {
-                                // Add the maxChars value to the metadata
-                                metadata[mappedKey] = Math.abs(Number(result.value));
-                            }
-                        }
-                        else {
-                            // Add the $context or $id or other attributes value to the metadata
-                            // TODO: why are we including everything? arent we only interested in relevant inline metadata?
-                            metadata[mappedKey] = result.value;
-                        }
-                    }
-                }
-            }
-        });
-    }
-    return metadata;
-}

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

@@ -1,14 +0,0 @@
-import * as t from '@babel/types';
-import { ParsingConfig, ParsingOutput } from '../types.js';
-/**
- * For the processTranslationCall function, this function handles the case where a other translation call is used.
- * Error is pushed if the other translation call is used.
- * @param arg - The argument to parse
- * @param config - The configuration to use
- * @param output - The output to use
- */
-export declare function handleInvalidTranslationCall({ arg, config, output, }: {
-    arg: t.ArgumentPlaceholder | t.SpreadElement | t.Expression;
-    config: ParsingConfig;
-    output: ParsingOutput;
-}): void;

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

@@ -1,24 +0,0 @@
-import * as t from '@babel/types';
-import { warnNonStringSync, warnTemplateLiteralSync, } from '../../../../../console/index.js';
-import generateModule from '@babel/generator';
-// Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
-/**
- * For the processTranslationCall function, this function handles the case where a other translation call is used.
- * Error is pushed if the other translation call is used.
- * @param arg - The argument to parse
- * @param config - The configuration to use
- * @param output - The output to use
- */
-export function handleInvalidTranslationCall({ arg, config, output, }) {
-    if (config.ignoreDynamicContent)
-        return;
-    if (t.isTemplateLiteral(arg)) {
-        // Specific error for template literals
-        output.errors.push(warnTemplateLiteralSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-    }
-    else {
-        // Generic error
-        output.errors.push(warnNonStringSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-    }
-}

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

@@ -1,19 +0,0 @@
-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 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 declare function handleLiteralTranslationCall({ arg, metadata, config, output, index, }: {
-    arg: t.StringLiteral | t.TemplateLiteral;
-    metadata: InlineMetadata;
-    config: ParsingConfig;
-    output: ParsingOutput;
-    index?: number;
-}): void;