egret-cli/lib/publish-plugins/generate-version.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments)).next());
    });
};
const path = require('path');
const ast = require('egret-typescript-ast');
const fs = require('fs-extra-promise');
const util = require('egret-node-utils');
const stream = require('stream');
const resource = require('./resource');
let hook = { name: "generateVersion", execute: null };
hook.execute = (env) => __awaiter(this, void 0, void 0, function* () {
    let result = yield ast.findDecorator(path.join(env.root, "src/Main.ts"));
    result = result.filter(item => item.name == "RES.mapConfig");
    yield new GenerateVersion().execute(env, result);
});
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = hook;
class GenerateVersion {
    execute(env, decorators) {
        return __awaiter(this, void 0, Promise, function* () {
            let sourceRoot = env.root;
            let releasePath = env.releaseFolder;
            console.log(`${process.platform}_${process.arch}`);
            console.log(sourceRoot, releasePath, decorators);
            if (!decorators || !decorators.length) {
                throw new Error("no RES.config found");
            }
            let resourceFileNames = decorators.map(item => item.paramters[0]);
            let firstResourceFileName = resourceFileNames[0];
            let resourceRoots = ["resource"]; //decorators.map(item => item.generics)[0][0];
            let firstResourceRoot = resourceRoots[0];
            let mapper = resourceRoot => path.join(sourceRoot, resourceRoot);
            let list = yield util.walk(resourceRoots.map(mapper), (p) => {
                if (path.basename(p).charAt(0) == ".") {
                    return false;
                }
                return true;
            });
            var resPath = path.join(sourceRoot, firstResourceFileName);
            //TODO:这里报错不会输出
            try {
                var resObj = yield fs.readJSONAsync(resPath);
                yield resource.execute(resPath, env, firstResourceRoot);
            }
            catch (e) {
                console.log(e);
            }
            process.exit();
            var resourceOutputModeList = ["default"]; //, "ios"
            var length = list.length;
            let resourceMapper = (element) => __awaiter(this, void 0, void 0, function* () {
                for (let filePath of list) {
                    var sourceFilePath = path.relative(sourceRoot, filePath);
                    //resource.json文件不被混淆
                    let isResourceFile = false;
                    let isFirstResourceFile = false;
                    let index = resourceFileNames.indexOf(sourceFilePath);
                    if (index == 0) {
                        isFirstResourceFile = true;
                        isResourceFile = true;
                    }
                    else if (index > 0) {
                        isResourceFile = true;
                    }
                    if (isResourceFile) {
                        if (!isFirstResourceFile) {
                            //后续配置文件单纯拷贝
                            //todo没准也要生成crc32一份
                            fs.copySync(filePath, path.join(releasePath, sourceFilePath));
                        }
                        continue;
                    }
                    ;
                    var resRoot = element == "default" ? "resource" : "resource-" + element;
                    var buffer = yield fs.readFileAsync(filePath);
                    let sourceStream = fs.createReadStream(filePath);
                    // let env = {
                    //     filePath, content: buffer, sourceRoot
                    // }
                    //
                    // let list: PublishFileHook[] = [euiThemeJsonFileHook];
                    //
                    //
                    // if (await euiThemeJsonFileHook.filter(env)) {
                    //     buffer = await euiThemeJsonFileHook.execute(env);
                    //     sourceStream.pipe(euiThemeJsonFileHook.transform);
                    // }
                    let transform = new GenerateReleaseFileTransform(resObj, sourceFilePath, resRoot, releasePath);
                    // appendDataToRes(sourceFilePath, txtCrc32, size, resRoot);
                    transform.on("finish", () => console.log("onFinish", this['sourceFilePath']));
                    transform.on("handled", function () {
                        let sourceFilePath = this['sourceFilePath'];
                        console.log("onHandled", sourceFilePath);
                        // console.log('xxx', sourceFilePath);
                        //
                        // console.log('yyy', getConfig(resObj, sourceFilePath, resRoot))
                        // console.log("zzz", resObj)
                        var item = getConfig(resObj, sourceFilePath, resRoot);
                        let outputFileName = item.url;
                        let outputFilePath = path.join(releasePath, outputFileName);
                        // console.log("write : " + outputFileName)
                        try {
                            if (fs.existsSync(path.dirname(outputFilePath)) == false) {
                                fs.mkdirSync(path.dirname(outputFilePath));
                            }
                        }
                        catch (e) {
                            console.log(e);
                        }
                        console.log("write 222: " + outputFileName);
                        // this.pipe(fs.createWriteStream(outputFilePath));
                        fs.writeFile(outputFilePath, item.data);
                    });
                    let stream = sourceStream.pipe(transform);
                }
            });
            yield fs.mkdirpAsync(releasePath);
            yield fs.mkdirpAsync(path.join(releasePath, "resource"));
            yield Promise.all(resourceOutputModeList.map(resourceMapper));
            yield fs.writeFileAsync(path.join(releasePath, firstResourceFileName), JSON.stringify(resObj));
        });
    }
}
exports.GenerateVersion = GenerateVersion;
function onFinish(invoker) {
    return new Promise((resolve, reject) => {
        invoker.on("finish", resolve);
        invoker.on("error", reject);
    });
}
function getConfig(resConfig, sourceFilePath, resRoot) {
    let resourcesList = resConfig.resources;
    for (let item of resourcesList) {
        if (item.virtualUrl) {
            if (item.virtualUrl == sourceFilePath) {
                return item;
            }
        }
        if (item.url == sourceFilePath) {
            return item;
        }
    }
    let name = "$egret$" + GenerateReleaseFileTransform.appendDataToResIndex++;
    let url = sourceFilePath.replace(resRoot + "/", "");
    let item = { name: name, url: url };
    resourcesList.push(item);
    return item;
}
class GenerateReleaseFileTransform extends stream.Transform {
    constructor(resConfig, sourceFilePath, resRoot, releaseRoot) {
        super();
        this.resConfig = resConfig;
        this.sourceFilePath = sourceFilePath;
        this.resRoot = resRoot;
        this.releaseRoot = releaseRoot;
        this.__chunks = [];
        this.__size = 0;
        this.on("data", this.onData.bind(this));
        this.on("end", this.onEnd.bind(this));
    }
    onData(data) {
        // console.log("onData",data);
    }
    onEnd() {
        console.log("onEnd", this.sourceFilePath);
        // console.log("size:",this.__size);
        var data = null;
        switch (this.__chunks.length) {
            case 0:
                data = new Buffer(0);
                break;
            case 1:
                data = this.__chunks[0];
                break;
            default:
                data = new Buffer(this.__size);
                for (var i = 0, pos = 0, l = this.__chunks.length; i < l; i++) {
                    var chunk = this.__chunks[i];
                    chunk.copy(data, pos);
                    pos += chunk.length;
                }
                break;
        }
        // console.log("onEnd");
        this.handleData(data);
    }
    _transform(chunk, encoding, callback) {
        console.log("onTransform");
        // crc32()
        // this._flush
        // setTimeout(callback, 300)
        this.__chunks.push(chunk);
        this.__size += chunk.length;
        this.push(chunk);
        callback();
    }
    _flush(callback) {
        callback();
    }
    handleData(chunk) {
        console.log(chunk);
        let resObj = this.resConfig;
        let found = false;
        let crc32 = require("../../temp/crc32")(chunk);
        let size = chunk.length;
        let resourcesList = resObj.resources;
        let outputFileBasename = crc32 + "_" + size + path.extname(this.sourceFilePath);
        let url = path.join(this.resRoot, crc32.substring(0, 2), outputFileBasename);
        let item = getConfig(this.resConfig, this.sourceFilePath, this.resRoot);
        item.size = size;
        item.url = url;
        item.crc32 = crc32;
        item.virtualUrl = this.sourceFilePath;
        item.data = chunk;
        console.log('transfrom complete : ' + url);
        this.emit("handled");
    }
}
GenerateReleaseFileTransform.appendDataToResIndex = 0;
class Publish extends fs.WriteStream {
    constructor(sourceFilePath) {
        super();
        this.sourceFilePath = sourceFilePath;
    }
}
//# sourceMappingURL=generate-version.js.map