hcordova 1.0.0

package/src/utils/DependencyChecker.js

@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) 2025 Huawei Device, Inc. Ltd. and <马弓手>.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class DependencyChecker {
+    constructor(api) {
+        this.api = api;
+        this.events = api.events;
+    }
+
+    /**
+     * 检查插件依赖是否满足要求
+     * @param {Object} pluginPackage - 插件的package.json内容
+     * @param {Object} projectInfo - 项目信息
+     * @returns {Object} 检查结果
+     */
+    checkDependencies(pluginPackage, projectInfo) {
+        this.events.emit('verbose', `Checking dependencies for plugin: ${pluginPackage.name}`);
+        
+        const results = {
+            satisfied: true,
+            errors: [],
+            warnings: []
+        };
+
+        // 检查平台支持
+        if (!this._checkPlatformSupport(pluginPackage, results)) {
+            return results;
+        }
+
+        // 检查引擎依赖
+        this._checkEngineDependencies(pluginPackage, projectInfo, results);
+
+        return results;
+    }
+
+    /**
+     * 检查平台支持
+     */
+    _checkPlatformSupport(pluginPackage, results) {
+        const cordovaConfig = pluginPackage.cordova;
+        
+        if (!cordovaConfig || !cordovaConfig.platforms) {
+            results.warnings.push(`Plugin ${pluginPackage.name} does not specify supported platforms in cordova.platforms`);
+            return true;
+        }
+
+        const supportedPlatforms = cordovaConfig.platforms;
+        
+        // 检查是否支持鸿蒙平台
+        const isSupported = supportedPlatforms.includes('ohos') || 
+                           supportedPlatforms.includes('harmonyos') ||
+                           supportedPlatforms.includes('harmony') ||
+                           supportedPlatforms.includes('openharmony');
+        
+        if (!isSupported) {
+            results.satisfied = false;
+            results.errors.push(
+                `Plugin ${pluginPackage.name} does not support HarmonyOS platform. ` +
+                `Supported platforms: ${supportedPlatforms.join(', ')}`
+            );
+            return false;
+        }
+
+        this.events.emit('verbose', `Plugin ${pluginPackage.name} supports HarmonyOS platform`);
+        return true;
+    }
+
+    /**
+     * 检查引擎依赖
+     */
+    _checkEngineDependencies(pluginPackage, projectInfo, results) {
+        const engines = pluginPackage.engines;
+        
+        if (!engines) {
+            this.events.emit('verbose', `No engine dependencies specified for plugin ${pluginPackage.name}`);
+            return;
+        }
+
+        // 检查 cordovaDependencies
+        if (engines.cordovaDependencies) {
+            this._checkCordovaVersionDependencies(engines.cordovaDependencies, pluginPackage, projectInfo, results);
+        }
+
+        // 检查平台特定依赖
+        if (engines['cordova-openharmony']) {
+            this._checkPlatformEngine('cordova-openharmony', engines['cordova-openharmony'], projectInfo, results);
+        }
+
+        // 检查Node.js版本
+        if (engines.node) {
+            this._checkNodeVersion(engines.node, results);
+        }
+
+        // 检查npm版本
+        if (engines.npm) {
+            this._checkNpmVersion(engines.npm, results);
+        }
+    }
+
+    /**
+     * 检查Cordova版本依赖
+     */
+    _checkCordovaVersionDependencies(cordovaDependencies, pluginPackage, projectInfo, results) {
+        const pluginVersion = pluginPackage.version;
+        
+        // 查找适用于当前插件版本的依赖规则
+        let dependencyRules = null;
+        
+        // 按版本号排序，找到适用的规则
+        const versions = Object.keys(cordovaDependencies).sort(this._versionCompareReverse);
+        for (const version of versions) {
+            if (this._versionSatisfies(pluginVersion, version)) {
+                dependencyRules = cordovaDependencies[version];
+                break;
+            }
+        }
+
+        // 如果没有找到特定版本的规则，使用默认规则
+        if (!dependencyRules && cordovaDependencies) {
+            dependencyRules = cordovaDependencies;
+        }
+
+        if (dependencyRules) {
+            this.events.emit('verbose', `Found dependency rules for plugin version ${pluginVersion}`);
+            
+            // 检查各个依赖
+            for (const [engine, requirement] of Object.entries(dependencyRules)) {
+                this._checkPlatformEngine(engine, requirement, projectInfo, results);
+            }
+        }
+    }
+
+    /**
+     * 检查平台引擎版本
+     */
+    _checkPlatformEngine(engine, requirement, projectInfo, results) {
+        let currentVersion;
+
+        switch (engine) {
+            case 'cordova-openharmony':
+            case 'cordova-harmonyos':
+            case 'ohos':
+            case 'harmony':
+            case 'harmonyos':
+                currentVersion = projectInfo.cordovaHarmonyVersion;
+                break;
+            case 'cordova':
+                currentVersion = projectInfo.cordovaVersion;
+                break;
+            default:
+                results.warnings.push(`Unknown engine dependency: ${engine}`);
+                return;
+        }
+
+        if (!currentVersion) {
+            results.warnings.push(`Current version of ${engine} is not available`);
+            return;
+        }
+
+        if (!this._versionSatisfies(currentVersion, requirement)) {
+            results.satisfied = false;
+            results.errors.push(
+                `Plugin requires ${engine} ${requirement}, but current version is ${currentVersion}`
+            );
+        } else {
+            this.events.emit('verbose', `✓ ${engine} version ${currentVersion} satisfies requirement ${requirement}`);
+        }
+    }
+
+    /**
+     * 检查Node.js版本
+     */
+    _checkNodeVersion(requirement, results) {
+        const currentNodeVersion = process.version.replace('v', '');
+
+        if (!this._versionSatisfies(currentNodeVersion, requirement)) {
+            results.warnings.push(
+                `Plugin recommends Node.js ${requirement}, but current version is ${currentNodeVersion}`
+            );
+        } else {
+            this.events.emit('verbose', `✓ Node.js version ${currentNodeVersion} satisfies requirement ${requirement}`);
+        }
+    }
+
+    /**
+     * 检查npm版本
+     */
+    _checkNpmVersion(requirement, results) {
+        try {
+            const { execSync } = require('child_process');
+            const npmVersion = execSync('npm --version', { encoding: 'utf8' }).trim();
+
+            if (!this._versionSatisfies(npmVersion, requirement)) {
+                results.warnings.push(
+                    `Plugin recommends npm ${requirement}, but current version is ${npmVersion}`
+                );
+            } else {
+                this.events.emit('verbose', `✓ npm version ${npmVersion} satisfies requirement ${requirement}`);
+            }
+        } catch (error) {
+            results.warnings.push(`Could not check npm version: ${error.message}`);
+        }
+    }
+
+    /**
+     * 简单的版本比较函数
+     * @param {string} version - 当前版本
+     * @param {string} requirement - 版本要求
+     * @returns {boolean} 是否满足要求
+     */
+    _versionSatisfies(version, requirement) {
+        if (!version || !requirement) {
+            return false;
+        }
+
+        // 处理通配符
+        if (requirement === '*' || requirement === 'latest' || requirement === '') {
+            return true;
+        }
+
+        // 清理版本号
+        const cleanVersion = this._cleanVersion(version);
+        const cleanRequirement = this._cleanVersion(requirement);
+
+        try {
+            // 处理范围操作符
+            if (requirement.startsWith('^')) {
+                // ^1.2.3 表示 >=1.2.3 <2.0.0
+                return this._caretSatisfies(cleanVersion, cleanRequirement);
+            } else if (requirement.startsWith('~')) {
+                // ~1.2.3 表示 >=1.2.3 <1.3.0
+                return this._tildeSatisfies(cleanVersion, cleanRequirement);
+            } else if (requirement.startsWith('>=')) {
+                // >=1.2.3
+                return this._compareVersions(cleanVersion, cleanRequirement) >= 0;
+            } else if (requirement.startsWith('<=')) {
+                // <=1.2.3
+                return this._compareVersions(cleanVersion, cleanRequirement) <= 0;
+            } else if (requirement.startsWith('>')) {
+                // >1.2.3
+                return this._compareVersions(cleanVersion, cleanRequirement) > 0;
+            } else if (requirement.startsWith('<')) {
+                // <1.2.3
+                return this._compareVersions(cleanVersion, cleanRequirement) < 0;
+            } else {
+                // 精确匹配 1.2.3
+                return this._compareVersions(cleanVersion, cleanRequirement) === 0;
+            }
+        } catch (error) {
+            // 如果版本比较失败，默认返回 true 避免阻塞安装
+            this.events.emit('verbose', `Version comparison failed: ${version} vs ${requirement}, defaulting to true`);
+            return true;
+        }
+    }
+
+    /**
+     * 处理 ^ 操作符
+     */
+    _caretSatisfies(version, requirement) {
+        const versionParts = version.split('.').map(Number);
+        const reqParts = requirement.split('.').map(Number);
+        
+        // 主版本必须相等
+        if (versionParts[0] !== reqParts[0]) {
+            return false;
+        }
+        
+        // 次版本和修订版本必须 >= 要求版本
+        return this._compareVersions(version, requirement) >= 0;
+    }
+
+    /**
+     * 处理 ~ 操作符
+     */
+    _tildeSatisfies(version, requirement) {
+        const versionParts = version.split('.').map(Number);
+        const reqParts = requirement.split('.').map(Number);
+        
+        // 主版本和次版本必须相等
+        if (versionParts[0] !== reqParts[0] || versionParts[1] !== reqParts[1]) {
+            return false;
+        }
+        
+        // 修订版本必须 >= 要求版本
+        return this._compareVersions(version, requirement) >= 0;
+    }
+
+    /**
+     * 比较两个版本号
+     * @param {string} v1 - 版本1
+     * @param {string} v2 - 版本2
+     * @returns {number} -1: v1 < v2, 0: v1 = v2, 1: v1 > v2
+     */
+    _compareVersions(v1, v2) {
+        const parts1 = v1.split('.').map(part => {
+            const num = parseInt(part, 10);
+            return isNaN(num) ? 0 : num;
+        });
+        const parts2 = v2.split('.').map(part => {
+            const num = parseInt(part, 10);
+            return isNaN(num) ? 0 : num;
+        });
+
+        const maxLength = Math.max(parts1.length, parts2.length);
+        
+        for (let i = 0; i < maxLength; i++) {
+            const p1 = parts1[i] || 0;
+            const p2 = parts2[i] || 0;
+            
+            if (p1 < p2) return -1;
+            if (p1 > p2) return 1;
+        }
+        
+        return 0;
+    }
+
+    /**
+     * 反向版本比较（用于排序）
+     */
+    _versionCompareReverse(a, b) {
+        return -this._compareVersions(a, b);
+    }
+
+    /**
+     * 清理版本号，移除操作符
+     */
+    _cleanVersion(version) {
+        // 移除 ^ ~ > >= < <= 等操作符
+        return version.replace(/[\^~><=]/g, '');
+    }
+
+    /**
+     * 获取项目信息
+     */
+    getProjectInfo(cordovaHarmonyVersion) {
+        return {
+            cordovaVersion: this._getCordovaVersion(),
+            cordovaHarmonyVersion: cordovaHarmonyVersion,
+            nodeVersion: process.version.replace('v', ''),
+            npmVersion: this._getNpmVersion()
+        };
+    }
+
+    /**
+     * 获取Cordova版本
+     */
+    _getCordovaVersion() {
+        try {
+            const { execSync } = require('child_process');
+            return execSync('cordova --version', { encoding: 'utf8' }).trim();
+        } catch (error) {
+            return 'unknown';
+        }
+    }
+
+    /**
+     * 获取npm版本
+     */
+    _getNpmVersion() {
+        try {
+            const { execSync } = require('child_process');
+            return execSync('npm --version', { encoding: 'utf8' }).trim();
+        } catch (error) {
+            return 'unknown';
+        }
+    }
+}
+
+module.exports = DependencyChecker;