mixone/copy_file/btc/index.js

MixOne is a Node scaffolding tool implemented based on Vite, used for compiling HTML5, JavasCript, Vue, React and other codes. It supports packaging Web applications with multiple HTML entry points (BS architecture) and desktop installation packages (CS a

const fs = require('fs');
const path = require('path');
const byteCode = require('bytenode');

console.log('Node.js version:', process.version);
console.log('Electron version:', process.versions.electron);

/**
 * 文件编译器 - 将源目录中的所有文件进行字节码编译并保存到目标目录
 * @param {string} source - 源文件夹路径
 * @param {string} destination - 目标文件夹路径
 * @returns {Promise<string[]>} 返回所有处理的文件路径列表
 */
async function compileFiles(source, destination) {
    const allFiles = [];
    
    // 递归读取目录中的所有文件
    function getAllFiles(dir, fileList = []) {
        const files = fs.readdirSync(dir);
        
        files.forEach(file => {
            const filePath = path.join(dir, file);
            const stat = fs.statSync(filePath);
            
            if (stat.isDirectory()) {
                // 如果是目录，递归读取
                getAllFiles(filePath, fileList);
            } else {
                // 如果是文件，添加到列表
                fileList.push(filePath);
            }
        });
        
        return fileList;
    }
    
    try {
        // 检查源目录是否存在
        if (!fs.existsSync(source)) {
            throw new Error(`The source directory does not exist: ${source}`);
        }
        
        // 获取所有文件路径
        const sourceFiles = getAllFiles(source);
        
        // 确保目标目录存在
        if (!fs.existsSync(destination)) {
            fs.mkdirSync(destination, { recursive: true });
        }
        
        // 处理每个文件
        for (const sourceFile of sourceFiles) {
            // 计算相对路径
            const relativePath = path.relative(source, sourceFile);
            const targetFile = path.join(destination, relativePath);
            
            // 确保目标文件的目录存在
            const targetDir = path.dirname(targetFile);
            if (!fs.existsSync(targetDir)) {
                fs.mkdirSync(targetDir, { recursive: true });
            }
            
            // 检查文件扩展名，只对JavaScript文件进行字节码编译
            const ext = path.extname(sourceFile).toLowerCase();
            if (ext === '.js') {
                try {
                    // 对JavaScript文件进行字节码编译
                    const targetJscFile = targetFile.replace('.js', '.jsc');
                    byteCode.compileFile({
                        filename: sourceFile,
                        output: targetJscFile
                    });
                    allFiles.push(targetJscFile);
                } catch (compileError) {
                    console.error(`Compilation failed ${sourceFile}:`, compileError.message);
                    // 如果编译失败，直接复制原文件
                    fs.copyFileSync(sourceFile, targetFile);
                    console.log(`Copied: ${sourceFile} -> ${targetFile}`);
                    allFiles.push(targetFile);
                }
            } else {
                // 非JavaScript文件直接复制
                fs.copyFileSync(sourceFile, targetFile);
                allFiles.push(targetFile);
            }
        }
        return allFiles;
        
    } catch (error) {
        console.error('Processing failed:', error.message);
        throw error;
    }
}

// 命令行参数处理
function parseArguments() {
    const args = process.argv.slice(2);
    const params = {};
    
    for (let i = 0; i < args.length; i += 2) {
        const key = args[i];
        const value = args[i + 1];
        
        if (key === '--source') {
            params.source = value;
        } else if (key === '--destination') {
            params.destination = value;
        }
    }
    
    return params;
}

// 主函数
async function main() {
    try {
        const { source, destination } = parseArguments();
        
        if (!source || !destination) {
            console.error('Usage: electron ./out/.temp --source <source directory> --destination <destination directory>');
            process.exit(1);
        }
        
        const processedFiles = await compileFiles(source, destination);
        console.log(`ByteCode successfully processed ${processedFiles.length} files`);
        process.exit(0);
    } catch (error) {
        console.error('ByteCode Compile Execution failed:', error.message);

        process.exit(1);
    }
}

// 执行主函数
main();