@mindev/min-cli/lib/class/XcxNode.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const class_1 = require("../class");
const util_1 = require("../util");
/**
 * 小程序节点类，用于创建生成节点树
 *
 * @export
 * @class XcxNode
 */
class XcxNode {
    /**
     * Creates an instance of XcxNode.
     * @param {Request} request
     * @param {XcxNode} [root]
     * @memberof XcxNode
     */
    constructor(request, root) {
        /**
         * 子节点列表
         *
         * @type {XcxNode[]}
         * @memberof XcxNode
         */
        this.children = [];
        /**
         * 可用的请求列表
         *
         * @type {Request.Core[]}
         * @memberof XcxNode
         */
        this.useRequests = [];
        /**
         * 缺失的请求列表
         *
         * @type {Request.Default[]}
         * @memberof XcxNode
         */
        this.lackRequests = [];
        if (root) {
            root.children.push(this);
        }
        this.request = request;
        try {
            this.wxFile = new class_1.WxFile(this.request);
            this.isAvailable = true;
        }
        catch (err) {
            util_1.log.error(err);
            // TODO
            // Add log to app.js
        }
        if (this.isAvailable) {
            // 从下一次的编译里移除
            util_1.xcxNext.removeLack(this.request.srcRelative);
        }
        else {
            // 将当前的请求地址记录到Next，用于下一次编译
            util_1.xcxNext.addLack(this.request.srcRelative);
            return;
        }
        this.cached();
        this.recursive();
        this.lack();
    }
    /**
     * 创建一个小程序节点树
     *
     * @static
     * @param {XcxNode.Options} options
     * @returns {(XcxNode | null)}
     * @memberof XcxNode
     */
    static create(options) {
        let { isMain, isForce, root } = options;
        if (isMain && root) {
            util_1.log.debug(`XcxNode.create 不能同时设定'option.parent' 和 'root'`);
        }
        let request = new class_1.Request(options);
        if (!request.src) {
            if (isMain) {
                util_1.log.error(`找不到入口：${request.request}`);
            }
            return null;
        }
        let xcxNode = util_1.xcxNodeCache.get(request.src);
        if (isForce || !xcxNode) {
            xcxNode = new XcxNode(request, root);
        }
        return xcxNode;
    }
    /**
     * 编译，更新依赖列表和保存文件
     *
     * @memberof XcxNode
     */
    compile() {
        if (!this.isAvailable)
            return;
        this.wxFile.updateDepends(this.useRequests);
        this.wxFile.save();
    }
    /**
     * 增加缓存
     *
     * @private
     * @memberof XcxNode
     */
    cached() {
        util_1.xcxNodeCache.set(this.request.src, this);
    }
    /**
     * 递归依赖
     *
     * @private
     * @memberof XcxNode
     */
    recursive() {
        if (!this.isAvailable)
            return;
        let depends = this.wxFile.getDepends();
        for (let i = 0; i < depends.length; i++) {
            let depend = depends[i];
            let { request, requestType, isVirtual } = depend;
            if (isVirtual) {
                this.resolveVirtual(depend);
                return;
            }
            // 创建一个节点
            let xcxNode = XcxNode.create({
                request,
                requestType,
                parent: this.request.src,
                isMain: false,
                root: this,
                isThreeNpm: this.request.isThreeNpm
            });
            if (!xcxNode) {
                // 增加缺失的请求
                this.lackRequests.push({
                    request,
                    requestType
                });
            }
            else if (xcxNode.isAvailable) {
                // 添加可用的请求
                this.useRequests.push({
                    request,
                    requestType,
                    src: xcxNode.request.src,
                    srcRelative: xcxNode.request.srcRelative,
                    ext: xcxNode.request.ext,
                    dest: xcxNode.request.dest,
                    destRelative: xcxNode.request.destRelative,
                    isThreeNpm: xcxNode.request.isThreeNpm
                });
            }
        }
    }
    resolveVirtual(depend) {
        let { request, requestType } = depend;
        let virtualPath = util_1.config.resolveVirtual[request];
        if (!virtualPath) {
            return;
        }
        if (!path.isAbsolute(virtualPath)) {
            virtualPath = path.join(util_1.config.cwd, virtualPath);
        }
        if (!path.extname(virtualPath)) {
            virtualPath += util_1.config.ext.js;
        }
        let src = virtualPath;
        let srcRelative = path.relative(util_1.config.cwd, src);
        let destRelative = util_1.src2destRelative(srcRelative);
        let dest = path.join(util_1.config.cwd, destRelative);
        this.useRequests.push({
            request,
            requestType,
            src,
            srcRelative,
            ext: util_1.config.ext.js,
            dest,
            destRelative,
            isThreeNpm: true,
            isVirtual: true
        });
    }
    /**
     * 处理缺失依赖列表
     *
     * @private
     * @memberof XcxNode
     */
    lack() {
        if (this.lackRequests.length > 0) {
            // 将当前的请求地址记录到Next，用于下一次编译
            util_1.xcxNext.addLack(this.request.srcRelative);
            // 打印缺失库的日志信息
            this.lackRequests.forEach(lackRequest => {
                util_1.log.error(`找不到模块：${lackRequest.request} in ${this.request.srcRelative}`);
            });
        }
        else {
            // 从下一次的编译里移除
            util_1.xcxNext.removeLack(this.request.srcRelative);
        }
    }
}
exports.XcxNode = XcxNode;