/**
 * 依赖检查工具
 * 
 * 用于检查可选依赖是否已安装，并提供友好的安装提示
 */ /**
 * 依赖包信息
 */ "use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: Object.getOwnPropertyDescriptor(all, name).get
    });
}
_export(exports, {
    get checkDependency () {
        return checkDependency;
    },
    get createDependencyError () {
        return createDependencyError;
    },
    get requireDependency () {
        return requireDependency;
    }
});
function _getRequireWildcardCache(nodeInterop) {
    if (typeof WeakMap !== "function") return null;
    var cacheBabelInterop = new WeakMap();
    var cacheNodeInterop = new WeakMap();
    return (_getRequireWildcardCache = function(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
    })(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
    if (!nodeInterop && obj && obj.__esModule) {
        return obj;
    }
    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
        return {
            default: obj
        };
    }
    var cache = _getRequireWildcardCache(nodeInterop);
    if (cache && cache.has(obj)) {
        return cache.get(obj);
    }
    var newObj = {
        __proto__: null
    };
    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
    for(var key in obj){
        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
            if (desc && (desc.get || desc.set)) {
                Object.defineProperty(newObj, key, desc);
            } else {
                newObj[key] = obj[key];
            }
        }
    }
    newObj.default = obj;
    if (cache) {
        cache.set(obj, newObj);
    }
    return newObj;
}
/**
 * 已知依赖包信息
 */ const KNOWN_DEPENDENCIES = {
    ky: {
        name: 'ky',
        description: '一个轻量级的 HTTP 客户端库，基于 fetch API',
        installCommand: 'pnpm add ky',
        installCommandNpm: 'npm install ky',
        installCommandYarn: 'yarn add ky',
        documentationUrl: 'https://github.com/sindresorhus/ky'
    },
    axios: {
        name: 'axios',
        description: '一个基于 Promise 的 HTTP 客户端，用于浏览器和 Node.js',
        installCommand: 'pnpm add axios',
        installCommandNpm: 'npm install axios',
        installCommandYarn: 'yarn add axios',
        documentationUrl: 'https://axios-http.com/'
    },
    undici: {
        name: 'undici',
        description: '一个高性能的 HTTP/1.1 客户端，Node.js 官方推荐',
        installCommand: 'pnpm add undici',
        installCommandNpm: 'npm install undici',
        installCommandYarn: 'yarn add undici',
        documentationUrl: 'https://undici.nodejs.org/'
    }
};
/**
 * 检测包管理器类型
 * 
 * @returns 包管理器类型（'pnpm' | 'npm' | 'yarn' | 'unknown'）
 */ function detectPackageManager() {
    // 检查环境变量
    if (typeof process !== 'undefined') {
        // 检查 pnpm
        if (process.env.npm_config_user_agent?.includes('pnpm')) {
            return 'pnpm';
        }
        // 检查 yarn
        if (process.env.npm_config_user_agent?.includes('yarn')) {
            return 'yarn';
        }
        // 检查 npm
        if (process.env.npm_config_user_agent?.includes('npm')) {
            return 'npm';
        }
    }
    // 检查是否存在 lock 文件（仅在 Node.js 环境中）
    if (typeof process !== 'undefined' && typeof require !== 'undefined' && process.cwd) {
        try {
            // 动态导入 Node.js 模块（避免浏览器环境报错）
            const fs = require('fs');
            const path = require('path');
            const cwd = process.cwd();
            if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) {
                return 'pnpm';
            }
            if (fs.existsSync(path.join(cwd, 'yarn.lock'))) {
                return 'yarn';
            }
            if (fs.existsSync(path.join(cwd, 'package-lock.json'))) {
                return 'npm';
            }
        } catch  {
        // 忽略错误（可能是浏览器环境）
        }
    }
    return 'unknown';
}
async function checkDependency(packageName) {
    try {
        // 在浏览器环境中，使用 Function 构造函数避免构建时解析
        // 这样可以确保动态导入在运行时执行
        if (typeof window !== 'undefined') {
            // 浏览器环境：使用 Function 构造函数
            const importFn = new Function('packageName', 'return import(packageName)');
            await importFn(packageName);
        } else {
            // Node.js 环境：直接导入
            await Promise.resolve(packageName).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
        }
        return true;
    } catch (error) {
        // 如果导入失败，检查是否是模块未找到错误
        if (error instanceof Error) {
            const errorMessage = error.message.toLowerCase();
            // 检查各种模块未找到的错误信息
            if (errorMessage.includes('cannot find module') || errorMessage.includes('cannot resolve') || errorMessage.includes('module not found') || errorMessage.includes('failed to resolve') || errorMessage.includes('does not exist') || errorMessage.includes('resolve') && errorMessage.includes(packageName)) {
                return false;
            }
            // 在浏览器环境中，某些构建工具的错误信息可能不同
            // 如果错误包含包名，也可能是未找到
            if (errorMessage.includes(packageName) && (errorMessage.includes('resolve') || errorMessage.includes('find') || errorMessage.includes('not found'))) {
                return false;
            }
        }
        // 其他错误（如语法错误、运行时错误等）不应该认为是未安装
        // 返回 true，让实际导入时再处理这些错误
        return true;
    }
}
function createDependencyError(packageName, context) {
    const depInfo = KNOWN_DEPENDENCIES[packageName];
    const packageManager = detectPackageManager();
    // 构建基础错误消息
    let message = `\n❌ 依赖包 "${packageName}" 未安装\n\n`;
    // 添加上下文信息
    if (context?.adapterName) {
        message += `适配器 "${context.adapterName}" 需要安装 "${packageName}" 依赖包。\n\n`;
    }
    if (depInfo) {
        message += `📦 包信息：${depInfo.description}\n\n`;
    }
    // 添加安装命令
    message += `📥 安装命令：\n`;
    if (depInfo) {
        switch(packageManager){
            case 'pnpm':
                message += `  ${depInfo.installCommand}\n`;
                break;
            case 'npm':
                message += `  ${depInfo.installCommandNpm}\n`;
                break;
            case 'yarn':
                message += `  ${depInfo.installCommandYarn}\n`;
                break;
            default:
                // 显示所有包管理器的命令
                message += `  ${depInfo.installCommand}\n`;
                message += `  ${depInfo.installCommandNpm}\n`;
                message += `  ${depInfo.installCommandYarn}\n`;
        }
    } else {
        // 未知包，使用通用命令
        switch(packageManager){
            case 'pnpm':
                message += `  pnpm add ${packageName}\n`;
                break;
            case 'npm':
                message += `  npm install ${packageName}\n`;
                break;
            case 'yarn':
                message += `  yarn add ${packageName}\n`;
                break;
            default:
                message += `  pnpm add ${packageName}\n`;
                message += `  npm install ${packageName}\n`;
                message += `  yarn add ${packageName}\n`;
        }
    }
    // 添加文档链接
    if (depInfo?.documentationUrl) {
        message += `\n📚 文档：${depInfo.documentationUrl}\n`;
    }
    // 添加说明
    message += `\n💡 提示：这些依赖包是可选依赖，框架不会自动安装。\n`;
    message += `   请根据你的项目需求，在项目根目录安装对应的依赖包。\n`;
    return message;
}
async function requireDependency(packageName, context) {
    const isInstalled = await checkDependency(packageName);
    if (!isInstalled) {
        const errorMessage = createDependencyError(packageName, context);
        throw new Error(errorMessage);
    }
}

//# sourceMappingURL=dependencyCheck.js.map