gtx-cli 2.6.31 → 2.7.0

package/dist/react/jsx/wrapJsx.js

@@ -1,387 +0,0 @@
-import * as t from '@babel/types';
-import { isStaticExpression, isStaticValue } from './evaluateJsx.js';
-import { warnTernarySync } from '../../console/index.js';
-function wrapJsxExpression(node, options, isMeaningful, mark) {
-    const expression = t.isParenthesizedExpression(node.expression)
-        ? node.expression.expression
-        : node.expression;
-    // Ignore template literals containing quasis - they should not be counted as meaningful
-    if (t.isTemplateLiteral(expression) && expression.expressions.length > 0) {
-        return {
-            node,
-            hasMeaningfulContent: false,
-            wrappedInT: false,
-        };
-    }
-    // Handle both JSX Elements and Fragments
-    if (t.isJSXElement(expression) ||
-        t.isJSXFragment(expression) ||
-        t.isStringLiteral(expression) ||
-        t.isJSXText(expression) ||
-        t.isTemplateLiteral(expression)) {
-        if (t.isJSXElement(expression) || t.isJSXFragment(expression)) {
-            const result = wrapJsxElement(expression, options, isMeaningful, mark);
-            // re-wrap the result in a JSXExpressionContainer
-            if (t.isParenthesizedExpression(node.expression)) {
-                node.expression.expression = result.node;
-            }
-            else {
-                node.expression = result.node;
-            }
-            return {
-                node,
-                hasMeaningfulContent: result.hasMeaningfulContent,
-                wrappedInT: result.wrappedInT,
-            };
-        }
-        return {
-            node,
-            hasMeaningfulContent: isMeaningful(expression),
-            wrappedInT: false,
-        };
-    }
-    // Handle conditional expressions (ternary)
-    else if (t.isConditionalExpression(expression)) {
-        const consequent = t.isParenthesizedExpression(expression.consequent)
-            ? expression.consequent.expression
-            : expression.consequent;
-        const alternate = t.isParenthesizedExpression(expression.alternate)
-            ? expression.alternate.expression
-            : expression.alternate;
-        // Handle consequent
-        if (t.isJSXElement(consequent) || t.isJSXFragment(consequent)) {
-            const result = handleJsxElement(consequent, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.consequent)) {
-                expression.consequent.expression = result.node;
-            }
-            else {
-                expression.consequent = result.node;
-            }
-            // Warn about ternary (should use branch instead)
-            if (result.wrappedInT && !mark) {
-                options.warnings.push(warnTernarySync(options.file, `${consequent.loc?.start?.line}:${consequent.loc?.start?.column}`));
-            }
-        }
-        else if (t.isConditionalExpression(consequent) ||
-            t.isLogicalExpression(consequent)) {
-            // Recursively handle nested ternary in consequent
-            const consequentResult = wrapJsxExpression(t.jsxExpressionContainer(consequent), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(consequentResult.node) &&
-                t.isExpression(consequentResult.node.expression)) {
-                expression.consequent = consequentResult.node.expression;
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.consequent)) {
-                    expression.consequent.expression = consequentResult.node.expression;
-                }
-                else {
-                    expression.consequent = consequentResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(consequent) &&
-            consequent.expressions.length > 0) {
-            // Ignore template literals in consequent with expressions (${}), don't wrap them
-            // Do nothing
-        }
-        else {
-            if (isStaticValue(consequent) && isMeaningful(consequent)) {
-                const wrapped = wrapExpressionWithT(consequent, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.consequent)) {
-                    expression.consequent.expression = wrapped;
-                }
-                else {
-                    expression.consequent = wrapped;
-                }
-            }
-        }
-        // Handle alternate
-        if (t.isJSXElement(alternate) || t.isJSXFragment(alternate)) {
-            const result = handleJsxElement(alternate, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.alternate)) {
-                expression.alternate.expression = result.node;
-            }
-            else {
-                expression.alternate = result.node;
-            }
-        }
-        else if (t.isConditionalExpression(alternate) ||
-            t.isLogicalExpression(alternate)) {
-            // Recursively handle nested ternary in alternate
-            const alternateResult = wrapJsxExpression(t.jsxExpressionContainer(alternate), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(alternateResult.node) &&
-                t.isExpression(alternateResult.node.expression)) {
-                expression.alternate = alternateResult.node.expression;
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.alternate)) {
-                    expression.alternate.expression = alternateResult.node.expression;
-                }
-                else {
-                    expression.alternate = alternateResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(alternate) &&
-            alternate.expressions.length > 0) {
-            // Ignore template literals in alternate with expressions (${}), don't wrap them
-            // Do nothing
-        }
-        else {
-            if (isStaticValue(alternate) && isMeaningful(alternate)) {
-                const wrapped = wrapExpressionWithT(alternate, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.alternate)) {
-                    expression.alternate.expression = wrapped;
-                }
-                else {
-                    expression.alternate = wrapped;
-                }
-            }
-        }
-    }
-    // Handle logical expressions (&& and ||)
-    else if (t.isLogicalExpression(expression)) {
-        const left = t.isParenthesizedExpression(expression.left)
-            ? expression.left.expression
-            : expression.left;
-        const right = t.isParenthesizedExpression(expression.right)
-            ? expression.right.expression
-            : expression.right;
-        if (t.isJSXElement(left) || t.isJSXFragment(left)) {
-            const result = handleJsxElement(left, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.left)) {
-                expression.left.expression = result.node;
-            }
-            else {
-                expression.left = result.node;
-            }
-        }
-        else if (t.isLogicalExpression(left) || t.isConditionalExpression(left)) {
-            // Recursively handle nested logical expressions
-            const leftResult = wrapJsxExpression(t.jsxExpressionContainer(left), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(leftResult.node) &&
-                t.isExpression(leftResult.node.expression)) {
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.left)) {
-                    expression.left.expression = leftResult.node.expression;
-                }
-                else {
-                    expression.left = leftResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(left) && left.expressions.length > 0) {
-            // Ignore template literals with expressions (${}) in left side of logical expression
-            // Do nothing - don't wrap them
-        }
-        else {
-            if (isStaticValue(left) &&
-                isMeaningful(left) &&
-                expression.operator !== '&&') {
-                const wrapped = wrapExpressionWithT(left, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.left)) {
-                    expression.left.expression = wrapped;
-                }
-                else {
-                    expression.left = wrapped;
-                }
-            }
-        }
-        if (t.isJSXElement(right) || t.isJSXFragment(right)) {
-            const result = handleJsxElement(right, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.right)) {
-                expression.right.expression = result.node;
-            }
-            else {
-                expression.right = result.node;
-            }
-        }
-        else if (t.isLogicalExpression(right) ||
-            t.isConditionalExpression(right)) {
-            // Recursively handle nested logical expressions
-            const rightResult = wrapJsxExpression(t.jsxExpressionContainer(right), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(rightResult.node) &&
-                t.isExpression(rightResult.node.expression)) {
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.right)) {
-                    expression.right.expression = rightResult.node.expression;
-                }
-                else {
-                    expression.right = rightResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(right) && right.expressions.length > 0) {
-            // Ignore template literals with expressions (${}) in right side of logical expression
-            // Do nothing - don't wrap them
-        }
-        else {
-            if (isStaticValue(right) &&
-                isMeaningful(right) &&
-                expression.operator !== '||') {
-                const wrapped = wrapExpressionWithT(right, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.right)) {
-                    expression.right.expression = wrapped;
-                }
-                else {
-                    expression.right = wrapped;
-                }
-            }
-        }
-    }
-    const staticCheck = isStaticExpression(expression);
-    // If the expression is not static or if it's already wrapped in T,
-    // wrap with Var
-    if (!staticCheck.isStatic) {
-        return {
-            node: wrapWithVar(node, options, mark),
-            hasMeaningfulContent: false,
-            wrappedInT: false,
-        };
-    }
-    // If it's a static expression, check if it's meaningful
-    return {
-        node,
-        hasMeaningfulContent: false,
-        wrappedInT: false,
-    };
-}
-/**
- * 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 function wrapJsxElement(node, options, isMeaningful, mark) {
-    const TComponentName = options.TComponent || 'T';
-    const VarComponentName = options.VarComponent || 'Var';
-    // Handle both JSX Elements and Fragments
-    if (t.isJSXElement(node) || t.isJSXFragment(node)) {
-        // For elements, check if it's already a T or Var component
-        if (t.isJSXElement(node)) {
-            const name = node.openingElement.name;
-            if (t.isJSXIdentifier(name) &&
-                (name.name === TComponentName || name.name === VarComponentName)) {
-                return {
-                    node,
-                    hasMeaningfulContent: false,
-                    wrappedInT: name.name === TComponentName,
-                };
-            }
-        }
-        // Process children recursively (DFS postorder)
-        let hasMeaningfulContent = false;
-        let wrappedInT = false;
-        const processedChildren = node.children.map((child) => {
-            if (t.isJSXElement(child) || t.isJSXFragment(child)) {
-                const result = wrapJsxElement(child, options, isMeaningful, mark);
-                hasMeaningfulContent =
-                    hasMeaningfulContent || result.hasMeaningfulContent;
-                wrappedInT = wrappedInT || result.wrappedInT;
-                return result.node;
-            }
-            if (t.isJSXExpressionContainer(child)) {
-                const result = wrapJsxExpression(child, options, isMeaningful, mark);
-                wrappedInT = wrappedInT || result.wrappedInT;
-                hasMeaningfulContent =
-                    hasMeaningfulContent || result.hasMeaningfulContent;
-                // Expressions are never meaningful because they will either:
-                // 1. be sub-wrapped in a T (if they contain meaningful content)
-                // 2. be wrapped in a Var (if they are not static)
-                return result.node;
-            }
-            const isMeaningfulVal = isMeaningful(child);
-            if (isMeaningfulVal) {
-                hasMeaningfulContent = true;
-            }
-            return child;
-        });
-        node.children = processedChildren;
-        return {
-            node,
-            hasMeaningfulContent: hasMeaningfulContent,
-            wrappedInT: wrappedInT,
-        };
-    }
-    // For any other node types, return as-is
-    return {
-        node,
-        hasMeaningfulContent: false,
-        wrappedInT: false,
-    };
-}
-/**
- * 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 function handleJsxElement(rootNode, options, isMeaningful) {
-    const result = wrapJsxElement(rootNode, options, isMeaningful, true);
-    // Only wrap with T at the root level if there's meaningful content
-    if (result.hasMeaningfulContent) {
-        const output = wrapJsxElement(result.node, options, isMeaningful, false);
-        const node = wrapWithT(output.node, options, false);
-        return {
-            node,
-            hasMeaningfulContent: true,
-            wrappedInT: true,
-        };
-    }
-    return {
-        node: result.node,
-        hasMeaningfulContent: false,
-        wrappedInT: result.wrappedInT,
-    };
-}
-function wrapWithT(node, options, mark) {
-    if (mark) {
-        return node;
-    }
-    const TComponentName = options.TComponent || 'T';
-    const uniqueId = `${options.idPrefix}.${options.idCount}`;
-    options.modified = true;
-    options.idCount++;
-    if (!options.usedImports.includes(TComponentName)) {
-        options.usedImports.push(TComponentName);
-    }
-    if (options.createIds) {
-        return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [t.jsxAttribute(t.jsxIdentifier('id'), t.stringLiteral(uniqueId))], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [node], false);
-    }
-    return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [node], false);
-}
-function wrapExpressionWithT(node, options, mark) {
-    if (mark) {
-        return node;
-    }
-    const TComponentName = options.TComponent || 'T';
-    const uniqueId = `${options.idPrefix}.${options.idCount}`;
-    options.modified = true;
-    options.idCount++;
-    if (!options.usedImports.includes(TComponentName)) {
-        options.usedImports.push(TComponentName);
-    }
-    if (options.createIds) {
-        return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [t.jsxAttribute(t.jsxIdentifier('id'), t.stringLiteral(uniqueId))], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [t.jsxExpressionContainer(node)], false);
-    }
-    return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [t.jsxExpressionContainer(node)], false);
-}
-function wrapWithVar(node, options, mark) {
-    if (mark) {
-        return node;
-    }
-    const VarComponentName = options.VarComponent || 'Var';
-    options.modified = true;
-    if (!options.usedImports.includes(VarComponentName)) {
-        options.usedImports.push(VarComponentName);
-    }
-    return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(VarComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(VarComponentName)), [node], false);
-}

package/dist/react/parse/addVitePlugin/index.d.ts

@@ -1,22 +0,0 @@
-/**
- * Adds the gt compiler plugin to the vite config file
- */
-export declare function addVitePlugin({ errors, warnings, filesUpdated, packageJson, tsconfigJson, }: {
-    errors: string[];
-    warnings: string[];
-    filesUpdated: string[];
-    packageJson?: {
-        type?: string;
-        dependencies?: Record<string, string>;
-        devDependencies?: Record<string, string>;
-    };
-    tsconfigJson?: {
-        compilerOptions?: {
-            module?: string;
-        };
-    };
-}): Promise<{
-    errors: string[];
-    warnings: string[];
-    filesUpdated: string[];
-}>;

package/dist/react/parse/addVitePlugin/index.js

@@ -1,41 +0,0 @@
-import findFilepath from '../../../fs/findFilepath.js';
-import { logger } from '../../../console/logger.js';
-import { installCompiler } from './installCompiler.js';
-import { updateViteConfig } from './updateViteConfig.js';
-import { exitSync } from '../../../console/logging.js';
-const VITE_CONFIG_PATH_BASE = './vite.config.';
-/**
- * Adds the gt compiler plugin to the vite config file
- */
-export async function addVitePlugin({ errors, warnings, filesUpdated, packageJson, tsconfigJson, }) {
-    // Resolve file path
-    const viteConfigPath = findFilepath([
-        VITE_CONFIG_PATH_BASE + 'js',
-        VITE_CONFIG_PATH_BASE + 'ts',
-        VITE_CONFIG_PATH_BASE + 'mjs',
-        VITE_CONFIG_PATH_BASE + 'mts',
-        VITE_CONFIG_PATH_BASE + 'cjs',
-        VITE_CONFIG_PATH_BASE + 'cts',
-    ]);
-    if (!viteConfigPath) {
-        logger.error(`No ${VITE_CONFIG_PATH_BASE}[js|ts|mjs|mts|cjs|cts] file found. Please add the @generaltranslation/compiler plugin to your vite configuration file:
-      import { vite as gtCompiler } from '@generaltranslation/compiler';
-      export default defineConfig({
-        plugins: [gtCompiler()],
-      });
-      `);
-        exitSync(1);
-    }
-    // Install @generaltranslation/compiler if not installed
-    await installCompiler({ packageJson });
-    // Update the config file
-    await updateViteConfig({
-        errors,
-        warnings,
-        filesUpdated,
-        viteConfigPath,
-        packageJson,
-        tsconfigJson,
-    });
-    return { errors, warnings, filesUpdated };
-}

package/dist/react/parse/addVitePlugin/installCompiler.d.ts

@@ -1,8 +0,0 @@
-/**
- * Installs @generaltranslation/compiler if not installed
- */
-export declare function installCompiler({ packageJson, }: {
-    packageJson?: {
-        type?: string;
-    };
-}): Promise<void>;

package/dist/react/parse/addVitePlugin/installCompiler.js

@@ -1,22 +0,0 @@
-import { logger } from '../../../console/logger.js';
-import { installPackage } from '../../../utils/installPackage.js';
-import { isPackageInstalled } from '../../../utils/packageJson.js';
-import { getPackageManager } from '../../../utils/packageManager.js';
-import chalk from 'chalk';
-/**
- * Installs @generaltranslation/compiler if not installed
- */
-export async function installCompiler({ packageJson, }) {
-    // Check if installed
-    if (isPackageInstalled('@generaltranslation/compiler', packageJson || {})) {
-        return;
-    }
-    // Animation
-    const spinner = logger.createSpinner();
-    spinner.start(`Installing @generaltranslation/compiler...`);
-    // Install
-    const packageManager = await getPackageManager();
-    await installPackage('@generaltranslation/compiler', packageManager, true);
-    // Animation
-    spinner.stop(chalk.green('Installed @generaltranslation/compiler.'));
-}

package/dist/react/parse/addVitePlugin/updateViteConfig.d.ts

@@ -1,19 +0,0 @@
-/**
- * - Reads the vite config file
- * - Updates the ast to add the gt compiler plugin
- * - Writes the file back to the filesystem
- */
-export declare function updateViteConfig({ errors, warnings, filesUpdated, viteConfigPath, packageJson, tsconfigJson, }: {
-    errors: string[];
-    warnings: string[];
-    filesUpdated: string[];
-    viteConfigPath: string;
-    packageJson?: {
-        type?: string;
-    };
-    tsconfigJson?: {
-        compilerOptions?: {
-            module?: string;
-        };
-    };
-}): Promise<void>;

package/dist/react/parse/addVitePlugin/updateViteConfig.js

@@ -1,120 +0,0 @@
-import { logger } from '../../../console/logger.js';
-import fs from 'node:fs';
-import chalk from 'chalk';
-import generateModule from '@babel/generator';
-import { parse } from '@babel/parser';
-import { needsCJS } from '../../../utils/parse/needsCJS.js';
-import { addCompilerImport } from './utils/addCompilerImport.js';
-import { checkCompilerImport } from './utils/checkCompilerImport.js';
-import { checkPluginInvocation } from './utils/checkPluginInvocation.js';
-import { addPluginInvocation } from './utils/addPluginInvocation.js';
-import { exitSync } from '../../../console/logging.js';
-// Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
-/**
- * - Reads the vite config file
- * - Updates the ast to add the gt compiler plugin
- * - Writes the file back to the filesystem
- */
-export async function updateViteConfig({ errors, warnings, filesUpdated, viteConfigPath, packageJson, tsconfigJson, }) {
-    // Animation
-    const spinner = logger.createSpinner();
-    spinner.start(`Adding gt compiler plugin to ${viteConfigPath}...`);
-    // Read the file
-    let code;
-    try {
-        code = await fs.promises.readFile(viteConfigPath, 'utf8');
-    }
-    catch (error) {
-        logger.error(`Error: Failed to read ${viteConfigPath}: ${error}`);
-        exitSync(1);
-    }
-    // Update the ast
-    let updatedCode, success;
-    try {
-        ({ updatedCode, success } = await updateViteConfigAst({
-            code,
-            errors,
-            warnings,
-            viteConfigPath,
-            packageJson,
-            tsconfigJson,
-        }));
-    }
-    catch (error) {
-        logger.error(`Error: Failed to update ${viteConfigPath}: ${error}`);
-        exitSync(1);
-    }
-    // Write the file
-    try {
-        await fs.promises.writeFile(viteConfigPath, updatedCode);
-        filesUpdated.push(viteConfigPath);
-    }
-    catch (error) {
-        logger.error(`Error: Failed to write ${viteConfigPath}: ${error}`);
-        exitSync(1);
-    }
-    // Animation
-    spinner.stop(success
-        ? chalk.green(`Success! Added gt compiler plugin to ${viteConfigPath}`)
-        : chalk.red(`Failed to add gt compiler plugin to ${viteConfigPath}. Continuing setup...`));
-}
-/**
- * Orchestrates AST manipulation
- * @param code - The code to update
- * @param errors - The errors to update
- * @param warnings - The warnings to update
- * @param viteConfigPath - The path to the vite config file
- * @param packageJson - The package.json file
- * @param tsconfigJson - The tsconfig.json file
- * @returns
- */
-async function updateViteConfigAst({ code, warnings, viteConfigPath, packageJson, tsconfigJson, }) {
-    // Parse the code
-    const ast = parse(code, {
-        sourceType: 'module',
-        plugins: ['jsx', 'typescript'],
-    });
-    // Get cjs or esm
-    const cjsEnabled = needsCJS({
-        ast,
-        warnings,
-        filepath: viteConfigPath,
-        packageJson,
-        tsconfigJson,
-    });
-    // Check if the compiler import is already present
-    let { hasCompilerImport, alias, namespaces } = checkCompilerImport(ast);
-    // Add the import declaration
-    if (!hasCompilerImport) {
-        addCompilerImport({ ast, cjsEnabled });
-        hasCompilerImport = true;
-        alias = 'gtCompiler';
-        namespaces = [];
-    }
-    // Check if plugin is already present
-    let pluginAlreadyPresent = false;
-    if (hasCompilerImport) {
-        pluginAlreadyPresent = checkPluginInvocation({ ast, alias, namespaces });
-    }
-    // Insert plugin invocation
-    let success = false;
-    if (!pluginAlreadyPresent) {
-        success = addPluginInvocation({ ast, alias, namespaces });
-        if (!success) {
-            warnings.push(`Failed to add gt compiler plugin to ${viteConfigPath}. Please add the plugin manually:
-import { vite as gtCompiler } from '@generaltranslation/compiler';
-export default defineConfig({
-  plugins: [gtCompiler()],
-});`);
-        }
-    }
-    // Generate the modified code
-    const output = generate(ast, {
-        retainLines: true,
-        retainFunctionParens: true,
-        comments: true,
-        compact: 'auto',
-    }, code);
-    return { updatedCode: output.code, success };
-}

package/dist/react/parse/addVitePlugin/utils/addCompilerImport.d.ts

@@ -1,9 +0,0 @@
-import { ParseResult } from '@babel/parser';
-import * as t from '@babel/types';
-/**
- * Given the vite config file ast, inserts the import declaration for the @generaltranslation/compiler package
- */
-export declare function addCompilerImport({ ast, cjsEnabled, }: {
-    ast: ParseResult<t.File>;
-    cjsEnabled: boolean;
-}): void;

package/dist/react/parse/addVitePlugin/utils/addCompilerImport.js

@@ -1,34 +0,0 @@
-import * as t from '@babel/types';
-/**
- * Given the vite config file ast, inserts the import declaration for the @generaltranslation/compiler package
- */
-export function addCompilerImport({ ast, cjsEnabled, }) {
-    if (cjsEnabled) {
-        handleCjsImport(ast);
-    }
-    else {
-        handleEsmImport(ast);
-    }
-}
-/**
- * Adds a CJS import declaration for the @generaltranslation/compiler package
- * @param ast - The ast of the file
- * const gtCompiler = require('@generaltranslation/compiler').vite;
- */
-function handleCjsImport(ast) {
-    const variableDeclaration = t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier('gtCompiler'), t.memberExpression(t.callExpression(t.identifier('require'), [
-            t.stringLiteral('@generaltranslation/compiler'),
-        ]), t.identifier('vite'))),
-    ]);
-    ast.program.body.unshift(variableDeclaration);
-}
-/**
- * Adds an ESM import declaration for the @generaltranslation/compiler package
- * @param ast - The ast of the file
- * import { vite as gtCompiler } from '@generaltranslation/compiler';
- */
-function handleEsmImport(ast) {
-    const importDeclaration = t.importDeclaration([t.importSpecifier(t.identifier('gtCompiler'), t.identifier('vite'))], t.stringLiteral('@generaltranslation/compiler'));
-    ast.program.body.unshift(importDeclaration);
-}

package/dist/react/parse/addVitePlugin/utils/addPluginInvocation.d.ts

@@ -1,11 +0,0 @@
-import * as t from '@babel/types';
-import { ParseResult } from '@babel/parser';
-/**
- * Adds the plugin invocation to the vite config file
- * Naive solution: look for an object with a plugins property only inside of a defineConfig call
- */
-export declare function addPluginInvocation({ ast, alias, namespaces, }: {
-    ast: ParseResult<t.File>;
-    alias: string | null;
-    namespaces: string[];
-}): boolean;