gtx-cli 2.6.29 → 2.6.30-alpha.0

package/dist/react/parse/wrapContent.js

@@ -1,162 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import * as t from '@babel/types';
-import { parse } from '@babel/parser';
-import traverseModule from '@babel/traverse';
-import generateModule from '@babel/generator';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
-const generate = generateModule.default || generateModule;
-import { isMeaningful } from '../jsx/evaluateJsx.js';
-import { handleJsxElement } from '../jsx/wrapJsx.js';
-import { getRelativePath } from '../../fs/findFilepath.js';
-import { generateImportMap, createImports, } from '../jsx/utils/parseAst.js';
-import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
-import { matchFiles } from '../../fs/matchFiles.js';
-import { Libraries } from '../../types/libraries.js';
-const IMPORT_MAP = {
-    T: { name: 'T', source: Libraries.GT_REACT },
-    Var: { name: 'Var', source: Libraries.GT_REACT },
-    GTT: { name: 'T', source: Libraries.GT_REACT },
-    GTVar: { name: 'Var', source: Libraries.GT_REACT },
-    GTProvider: { name: 'GTProvider', source: Libraries.GT_REACT },
-};
-/**
- * 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
- */
-export async function wrapContentReact(options, pkg, framework, errors, warnings) {
-    const filePatterns = options.src || DEFAULT_SRC_PATTERNS;
-    const files = matchFiles(process.cwd(), filePatterns);
-    const filesUpdated = [];
-    for (const file of files) {
-        const baseFileName = path.basename(file);
-        const configPath = path.relative(path.dirname(file), path.resolve(process.cwd(), options.config));
-        // Ensure the path starts with ./ or ../
-        const normalizedConfigPath = configPath.startsWith('.')
-            ? configPath
-            : './' + configPath;
-        const code = await fs.promises.readFile(file, 'utf8');
-        // Create relative path from src directory and remove extension
-        const relativePath = getRelativePath(file, process.cwd());
-        let ast;
-        try {
-            ast = 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;
-        const usedImports = [];
-        const { importAlias, initialImports } = 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;
-        traverse(ast, {
-            JSXElement(path) {
-                if (framework === 'next-pages' &&
-                    options.addGTProvider &&
-                    (baseFileName === '_app.tsx' || baseFileName === '_app.jsx')) {
-                    // Check if this is the Component element with pageProps
-                    const isComponentWithPageProps = t.isJSXElement(path.node) &&
-                        t.isJSXIdentifier(path.node.openingElement.name) &&
-                        path.node.openingElement.name.name === 'Component' &&
-                        path.node.openingElement.attributes.some((attr) => t.isJSXSpreadAttribute(attr) &&
-                            t.isIdentifier(attr.argument) &&
-                            attr.argument.name === 'pageProps');
-                    if (!isComponentWithPageProps) {
-                        return;
-                    }
-                    // Check if GTProvider already exists in the ancestors
-                    let hasGTProvider = false;
-                    let currentPath = path;
-                    while (currentPath.parentPath) {
-                        if (t.isJSXElement(currentPath.node) &&
-                            t.isJSXIdentifier(currentPath.node.openingElement.name) &&
-                            currentPath.node.openingElement.name.name === 'GTProvider') {
-                            hasGTProvider = true;
-                            break;
-                        }
-                        currentPath = currentPath.parentPath;
-                    }
-                    if (!hasGTProvider) {
-                        // Wrap the Component element with GTProvider
-                        const gtProviderJsx = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier('GTProvider'), [t.jsxSpreadAttribute(t.identifier('gtConfig'))], false), t.jsxClosingElement(t.jsxIdentifier('GTProvider')), [path.node]);
-                        path.replaceWith(gtProviderJsx);
-                        usedImports.push('GTProvider');
-                        usedImports.push({
-                            local: 'gtConfig',
-                            imported: 'default',
-                            source: normalizedConfigPath,
-                        });
-                        modified = true;
-                        path.skip();
-                        return;
-                    }
-                }
-                // Check if this JSX element has any JSX element ancestors
-                if (t.isJSXElement(path.parentPath?.node) ||
-                    t.isJSXExpressionContainer(path.parentPath?.node)) {
-                    // If we're nested inside JSX, 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 = handleJsxElement(path.node, opts, isMeaningful);
-                path.replaceWith(wrapped.node);
-                // Update global counters
-                modified = modified || opts.modified;
-                globalId = opts.idCount;
-            },
-        });
-        if (!modified)
-            continue;
-        const needsImport = usedImports.filter((imp) => typeof imp === 'string'
-            ? !initialImports.includes(imp)
-            : !initialImports.includes(imp.local));
-        if (needsImport.length > 0) {
-            createImports(ast, needsImport, IMPORT_MAP);
-        }
-        try {
-            const output = generate(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 fs.promises.writeFile(file, processedCode);
-            filesUpdated.push(file);
-        }
-        catch (error) {
-            errors.push(`Error: Failed to write ${file}: ${error}`);
-        }
-    }
-    return { filesUpdated };
-}

package/dist/react/utils/flattenDictionary.d.ts

@@ -1,20 +0,0 @@
-import { Dictionary, FlattenedDictionary, FlattenedJSONDictionary, JSONDictionary } from '../../types/data.js';
-/**
- * Flattens a nested dictionary by concatenating nested keys.
- * Throws an error if two keys result in the same flattened key.
- * @param {Record<string, any>} dictionary - The dictionary to flatten.
- * @param {string} [prefix=''] - The prefix for nested keys.
- * @returns {Record<string, React.ReactNode>} The flattened dictionary object.
- * @throws {Error} If two keys result in the same flattened key.
- */
-export default function flattenDictionary(dictionary: Dictionary, prefix?: string): FlattenedDictionary;
-/**
- * Flattens a nested dictionary containing only string values
- * Throws an error if two keys result in the same flattened key.
- * @param {JSONDictionary} dictionary - The dictionary to flatten.
- * @param {string} [prefix=''] - The prefix for nested keys.
- * @returns {FlattenedJSONDictionary} The flattened dictionary with string values.
- * @throws {Error} If two keys result in the same flattened key.
- * @throws {Error} If a value is an array.
- */
-export declare function flattenJsonDictionary(dictionary: JSONDictionary, prefix?: string): FlattenedJSONDictionary;

package/dist/react/utils/flattenDictionary.js

@@ -1,75 +0,0 @@
-import { logErrorAndExit } from '../../console/logging.js';
-const createDuplicateKeyError = (key) => `Duplicate key found in dictionary: "${key}"`;
-/**
- * Flattens a nested dictionary by concatenating nested keys.
- * Throws an error if two keys result in the same flattened key.
- * @param {Record<string, any>} dictionary - The dictionary to flatten.
- * @param {string} [prefix=''] - The prefix for nested keys.
- * @returns {Record<string, React.ReactNode>} The flattened dictionary object.
- * @throws {Error} If two keys result in the same flattened key.
- */
-export default function flattenDictionary(dictionary, prefix = '') {
-    const flattened = {};
-    for (const key in dictionary) {
-        if (dictionary.hasOwnProperty(key)) {
-            const newKey = prefix ? `${prefix}.${key}` : key;
-            if (typeof dictionary[key] === 'object' &&
-                dictionary[key] !== null &&
-                !Array.isArray(dictionary[key])) {
-                const nestedFlattened = flattenDictionary(dictionary[key], newKey);
-                for (const flatKey in nestedFlattened) {
-                    if (flattened.hasOwnProperty(flatKey)) {
-                        logErrorAndExit(createDuplicateKeyError(flatKey));
-                    }
-                    flattened[flatKey] = nestedFlattened[flatKey];
-                }
-            }
-            else {
-                if (flattened.hasOwnProperty(newKey)) {
-                    logErrorAndExit(createDuplicateKeyError(newKey));
-                }
-                flattened[newKey] = dictionary[key];
-            }
-        }
-    }
-    return flattened;
-}
-/**
- * Flattens a nested dictionary containing only string values
- * Throws an error if two keys result in the same flattened key.
- * @param {JSONDictionary} dictionary - The dictionary to flatten.
- * @param {string} [prefix=''] - The prefix for nested keys.
- * @returns {FlattenedJSONDictionary} The flattened dictionary with string values.
- * @throws {Error} If two keys result in the same flattened key.
- * @throws {Error} If a value is an array.
- */
-export function flattenJsonDictionary(dictionary, prefix = '') {
-    const flattened = {};
-    for (const key in dictionary) {
-        if (dictionary.hasOwnProperty(key)) {
-            const newKey = prefix ? `${prefix}.${key}` : key;
-            const value = dictionary[key];
-            if (Array.isArray(value)) {
-                logErrorAndExit(`Arrays are not supported in JSON dictionary at key: "${newKey}"`);
-            }
-            else if (typeof value === 'object' && value !== null) {
-                // Recursively flatten nested objects
-                const nestedFlattened = flattenJsonDictionary(value, newKey);
-                for (const flatKey in nestedFlattened) {
-                    if (flattened.hasOwnProperty(flatKey)) {
-                        logErrorAndExit(createDuplicateKeyError(flatKey));
-                    }
-                    flattened[flatKey] = nestedFlattened[flatKey];
-                }
-            }
-            else if (typeof value === 'string') {
-                // Handle string values
-                if (flattened.hasOwnProperty(newKey)) {
-                    logErrorAndExit(createDuplicateKeyError(newKey));
-                }
-                flattened[newKey] = value;
-            }
-        }
-    }
-    return flattened;
-}

package/dist/react/utils/getEntryAndMetadata.d.ts

@@ -1,5 +0,0 @@
-import { DictionaryEntry, DictionaryMetadata } from '../../types/data.js';
-export default function getEntryAndMetadata(value: DictionaryEntry): {
-    entry: string;
-    metadata?: DictionaryMetadata;
-};

package/dist/react/utils/getEntryAndMetadata.js

@@ -1,11 +0,0 @@
-export default function getEntryAndMetadata(value) {
-    if (Array.isArray(value)) {
-        if (value.length === 1) {
-            return { entry: value[0] };
-        }
-        if (value.length === 2) {
-            return { entry: value[0], metadata: value[1] };
-        }
-    }
-    return { entry: value };
-}

package/dist/react/utils/getVariableName.d.ts

@@ -1,25 +0,0 @@
-import { VariableType } from 'generaltranslation/types';
-/**
- * These are the names of the variable components as they appear in gt-next and gt-react
- */
-export declare const defaultVariableNames: {
-    readonly Var: "value";
-    readonly Num: "n";
-    readonly DateTime: "date";
-    readonly Currency: "cost";
-};
-/**
- * Minify the variable type from the name of the variable component (from gt-next and gt-react)
- * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
- * @returns The minified variable type
- */
-export declare const minifyVariableType: (variableType: keyof typeof defaultVariableNames) => VariableType;
-export declare const baseVariablePrefix = "_gt_";
-/**
- * Get the name of a variable
- * @param props - The props of the variable
- * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
- * @param id - The id of the variable
- * @returns The name of the variable
- */
-export declare function getVariableName(props: Record<string, any> | undefined, variableType: keyof typeof defaultVariableNames, id: number): string;

package/dist/react/utils/getVariableName.js

@@ -1,37 +0,0 @@
-/**
- * These are the names of the variable components as they appear in gt-next and gt-react
- */
-export const defaultVariableNames = {
-    Var: 'value',
-    Num: 'n',
-    DateTime: 'date',
-    Currency: 'cost',
-};
-const minifyVariableTypeMap = {
-    Var: 'v',
-    Num: 'n',
-    DateTime: 'd',
-    Currency: 'c',
-};
-/**
- * Minify the variable type from the name of the variable component (from gt-next and gt-react)
- * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
- * @returns The minified variable type
- */
-export const minifyVariableType = (variableType) => {
-    return minifyVariableTypeMap[variableType];
-};
-export const baseVariablePrefix = '_gt_';
-/**
- * Get the name of a variable
- * @param props - The props of the variable
- * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
- * @param id - The id of the variable
- * @returns The name of the variable
- */
-export function getVariableName(props = {}, variableType, id) {
-    if (props.name)
-        return props.name;
-    const baseVariableName = defaultVariableNames[variableType] || 'value';
-    return `${baseVariablePrefix}${baseVariableName}_${id}`;
-}

package/dist/setup/agentInstructions.d.ts

@@ -1,24 +0,0 @@
-import { SupportedLibraries } from '../types/index.js';
-export declare const CURSOR_GT_RULES_FILE = ".cursor/rules/gt-i18n.mdc";
-/**
- * Detect existing AI agent instruction files in the project.
- */
-export declare function findAgentFiles(): string[];
-/**
- * Find agent files that already contain GT instructions.
- */
-export declare function findAgentFilesWithInstructions(): string[];
-/**
- * Check if the .cursor/rules/ directory exists (for offering to create gt-i18n.mdc).
- */
-export declare function hasCursorRulesDir(): boolean;
-/**
- * Generate GT agent instructions content based on the detected library.
- */
-export declare function getAgentInstructions(library: SupportedLibraries): string;
-/**
- * Append or replace GT instructions in an agent file.
- * Skips writing if the file already contains identical instructions.
- * For .cursor/rules/gt.md, writes the file fresh (dedicated GT rules file).
- */
-export declare function appendAgentInstructions(filePath: string, instructions: string): boolean;

package/dist/setup/agentInstructions.js

@@ -1,138 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { getCLIVersion, getPackageVersion } from '../utils/packageJson.js';
-import { Libraries } from '../types/libraries.js';
-const INSTRUCTIONS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'instructions');
-const AGENT_FILE_PATHS = [
-    'CLAUDE.md',
-    'AGENTS.md',
-    'GPT.md',
-    'CHATGPT.md',
-    '.cursorrules',
-];
-const CURSOR_RULES_DIR = '.cursor/rules';
-export const CURSOR_GT_RULES_FILE = '.cursor/rules/gt-i18n.mdc';
-const GT_SECTION_START = '<!-- GT I18N RULES START -->';
-const GT_SECTION_END = '<!-- GT I18N RULES END -->';
-function getLibraryVersion(library) {
-    const packageJsonPath = path.resolve(process.cwd(), 'package.json');
-    if (!fs.existsSync(packageJsonPath))
-        return undefined;
-    try {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        return getPackageVersion(library, packageJson);
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Detect existing AI agent instruction files in the project.
- */
-export function findAgentFiles() {
-    const cwd = process.cwd();
-    const found = [];
-    for (const filePath of [...AGENT_FILE_PATHS, CURSOR_GT_RULES_FILE]) {
-        const fullPath = path.resolve(cwd, filePath);
-        if (fs.existsSync(fullPath)) {
-            found.push(filePath);
-        }
-    }
-    return found;
-}
-/**
- * Find agent files that already contain GT instructions.
- */
-export function findAgentFilesWithInstructions() {
-    const cwd = process.cwd();
-    const found = [];
-    for (const filePath of [...AGENT_FILE_PATHS, CURSOR_GT_RULES_FILE]) {
-        const fullPath = path.resolve(cwd, filePath);
-        if (fs.existsSync(fullPath)) {
-            const content = fs.readFileSync(fullPath, 'utf8');
-            if (content.includes(GT_SECTION_START)) {
-                found.push(filePath);
-            }
-        }
-    }
-    return found;
-}
-/**
- * Check if the .cursor/rules/ directory exists (for offering to create gt-i18n.mdc).
- */
-export function hasCursorRulesDir() {
-    const cursorRulesDir = path.resolve(process.cwd(), CURSOR_RULES_DIR);
-    return (fs.existsSync(cursorRulesDir) && fs.statSync(cursorRulesDir).isDirectory());
-}
-/**
- * Generate GT agent instructions content based on the detected library.
- */
-export function getAgentInstructions(library) {
-    const libraryVersion = getLibraryVersion(library);
-    const versionLine = libraryVersion
-        ? `- **${library}**: ${libraryVersion}\n- **gtx-cli**: v${getCLIVersion()}`
-        : `- **gtx-cli**: v${getCLIVersion()}`;
-    const base = fs.readFileSync(path.join(INSTRUCTIONS_DIR, 'base.md'), 'utf8');
-    let body = '';
-    const libToFile = {
-        [Libraries.GT_NEXT]: 'gt-next.md',
-        [Libraries.GT_REACT]: 'gt-react.md',
-        // TODO: add gt-react-native.md
-        [Libraries.GT_REACT_NATIVE]: 'gt-react.md',
-    };
-    const instructionFile = libToFile[library];
-    if (instructionFile) {
-        body += '\n\n'; // add two newlines between the base and the specific instructions
-        body += fs.readFileSync(path.join(INSTRUCTIONS_DIR, instructionFile), 'utf8');
-    }
-    return `${GT_SECTION_START}
-
-${versionLine}
-
-${base}${body}
-${GT_SECTION_END}`;
-}
-/**
- * Append or replace GT instructions in an agent file.
- * Skips writing if the file already contains identical instructions.
- * For .cursor/rules/gt.md, writes the file fresh (dedicated GT rules file).
- */
-export function appendAgentInstructions(filePath, instructions) {
-    const fullPath = path.resolve(process.cwd(), filePath);
-    // For .cursor/rules/gt.md, write as a standalone file with frontmatter
-    if (filePath === CURSOR_GT_RULES_FILE) {
-        const cursorContent = `---\ndescription: GT internationalization instructions\nalwaysApply: true\n---\n${instructions}\n`;
-        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-        if (fs.existsSync(fullPath)) {
-            const existing = fs.readFileSync(fullPath, 'utf8');
-            if (existing === cursorContent)
-                return false;
-        }
-        fs.writeFileSync(fullPath, cursorContent, 'utf8');
-        return true;
-    }
-    // For other files, read existing content and append/replace
-    let content = '';
-    if (fs.existsSync(fullPath)) {
-        content = fs.readFileSync(fullPath, 'utf8');
-    }
-    // Already has identical instructions — skip
-    if (content.includes(instructions))
-        return false;
-    const startIdx = content.indexOf(GT_SECTION_START);
-    const endIdx = startIdx !== -1 ? content.indexOf(GT_SECTION_END, startIdx) : -1;
-    if (startIdx !== -1 && endIdx !== -1) {
-        // Replace existing section
-        const before = content.substring(0, startIdx);
-        const after = content.substring(endIdx + GT_SECTION_END.length);
-        content = before + instructions + after;
-    }
-    else {
-        // Append to end
-        const separator = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
-        content = content + separator + '\n' + instructions + '\n';
-    }
-    fs.writeFileSync(fullPath, content, 'utf8');
-    return true;
-}

package/dist/setup/detectFramework.d.ts

@@ -1,31 +0,0 @@
-import { FrameworkObject } from '../types/index.js';
-/**
- * Detects the frontend framework used in the current project.
- *
- * Analyzes the project structure and dependencies to identify the framework.
- * Detection order: Mintlify → Next.js (App/Pages Router) → Gatsby → RedwoodJS → Vite → React.
- *
- * For Next.js projects, further determines whether it uses App Router or Pages Router
- * by checking for the presence of `app/` or `pages/` directories.
- *
- * @returns A promise resolving to a FrameworkObject containing:
- *   - `name`: The detected framework identifier (e.g., 'next-app', 'gatsby', 'react')
- *             or undefined if no framework is detected
- *   - `type`: The framework category (currently only 'react' for React-based frameworks)
- */
-export declare function detectFramework(): Promise<FrameworkObject | {
-    name: undefined;
-    type?: undefined;
-}>;
-/**
- * Detects if the current project is a Mintlify documentation project.
- *
- * Checks for the presence of docs.json (preferred) or mint.json (legacy) files.
- * For docs.json, validates that the $schema field contains "mintlify.com/docs.json".
- * Rejects projects with Next.js config files to avoid misclassification.
- *
- * @param _packageJson - The parsed package.json object (not used for Mintlify detection,
- *                       but kept for API consistency with other detection functions)
- * @returns True if the project is identified as a Mintlify project, false otherwise
- */
-export declare function isMintlifyProject(_packageJson: Record<string, any> | null): boolean;

package/dist/setup/detectFramework.js

@@ -1,106 +0,0 @@
-import { isPackageInstalled } from '../utils/packageJson.js';
-import { searchForPackageJson } from '../utils/packageJson.js';
-import fs from 'node:fs';
-import path from 'node:path';
-/* ----- MAIN ----- */
-/**
- * Detects the frontend framework used in the current project.
- *
- * Analyzes the project structure and dependencies to identify the framework.
- * Detection order: Mintlify → Next.js (App/Pages Router) → Gatsby → RedwoodJS → Vite → React.
- *
- * For Next.js projects, further determines whether it uses App Router or Pages Router
- * by checking for the presence of `app/` or `pages/` directories.
- *
- * @returns A promise resolving to a FrameworkObject containing:
- *   - `name`: The detected framework identifier (e.g., 'next-app', 'gatsby', 'react')
- *             or undefined if no framework is detected
- *   - `type`: The framework category (currently only 'react' for React-based frameworks)
- */
-export async function detectFramework() {
-    const packageJson = await searchForPackageJson();
-    if (isMintlifyProject(packageJson)) {
-        return { name: 'mintlify' };
-    }
-    if (!packageJson) {
-        return { name: undefined };
-    }
-    // Check for Next.js first
-    if (isPackageInstalled('next', packageJson, false, true)) {
-        // Determine if it's App Router or Pages Router
-        const cwd = process.cwd();
-        const hasAppDir = fs.existsSync(path.join(cwd, 'app')) ||
-            fs.existsSync(path.join(cwd, 'src', 'app'));
-        const hasPagesDir = fs.existsSync(path.join(cwd, 'pages')) ||
-            fs.existsSync(path.join(cwd, 'src', 'pages'));
-        // App Router takes precedence if both exist
-        if (hasAppDir) {
-            return { name: 'next-app', type: 'react' };
-        }
-        if (hasPagesDir) {
-            return { name: 'next-pages', type: 'react' };
-        }
-        // Default to app router for new Next.js projects
-        return { name: 'next-app', type: 'react' };
-    }
-    // Check for Gatsby
-    if (isPackageInstalled('gatsby', packageJson, false, true)) {
-        return { name: 'gatsby', type: 'react' };
-    }
-    // Check for RedwoodJS
-    if (isPackageInstalled('@redwoodjs/core', packageJson, false, true)) {
-        return { name: 'redwood', type: 'react' };
-    }
-    // Check for Vite
-    if (isPackageInstalled('vite', packageJson, false, true)) {
-        return { name: 'vite', type: 'react' };
-    }
-    // Check for React (generic)
-    if (isPackageInstalled('react', packageJson, false, true)) {
-        return { name: 'react', type: 'react' };
-    }
-    return { name: undefined };
-}
-// ----- HELPER FUNCTIONS ----- //
-/**
- * Detects if the current project is a Mintlify documentation project.
- *
- * Checks for the presence of docs.json (preferred) or mint.json (legacy) files.
- * For docs.json, validates that the $schema field contains "mintlify.com/docs.json".
- * Rejects projects with Next.js config files to avoid misclassification.
- *
- * @param _packageJson - The parsed package.json object (not used for Mintlify detection,
- *                       but kept for API consistency with other detection functions)
- * @returns True if the project is identified as a Mintlify project, false otherwise
- */
-export function isMintlifyProject(_packageJson) {
-    const cwd = process.cwd();
-    // Check for Next.js config files - if present, this is not a Mintlify project
-    const nextConfigFiles = [
-        'next.config.js',
-        'next.config.ts',
-        'next.config.mjs',
-        'next.config.cjs',
-    ];
-    for (const configFile of nextConfigFiles) {
-        if (fs.existsSync(path.join(cwd, configFile))) {
-            return false;
-        }
-    }
-    // Check for docs.json (preferred format)
-    const docsJsonPath = path.join(cwd, 'docs.json');
-    if (fs.existsSync(docsJsonPath)) {
-        try {
-            const docsJson = JSON.parse(fs.readFileSync(docsJsonPath, 'utf-8'));
-            // Validate the $schema field contains mintlify.com/docs.json
-            if (docsJson.$schema &&
-                docsJson.$schema.includes('mintlify.com/docs.json')) {
-                return true;
-            }
-        }
-        catch {
-            return false;
-        }
-    }
-    return false;
-}

package/dist/setup/frameworkUtils.d.ts

@@ -1,3 +0,0 @@
-import { FrameworkObject, ReactFrameworkObject } from '../types/index.js';
-export declare function getFrameworkDisplayName(frameworkObject: FrameworkObject): string;
-export declare function getReactFrameworkLibrary(frameworkObject: ReactFrameworkObject): string;