instruct-request-axios/lib/instructions/instruction.js

指令请求器

// 指令注册器
export default class Instruction {
    // 容器
    container = undefined;
    /*
    * 删除指令
    * @param mustRemove boolean 如果指定需要为行为负责 此选项指定后且callback不提供将不继续管理 指令池 而是直接delete掉
    * */
    delete(name, callback, triggerType = undefined, type = "front", mustRemove = false) {
        // 获取指令模块
        let Indexes = this.container[type];
        let result = false;
        if (Indexes) {
            if (triggerType) {
                let trigger = Indexes[triggerType];
                if (trigger && trigger[name]) {
                    delete trigger[name];
                    result = true;
                }
            }
            else {
                for (let key in Indexes) {
                    if (Indexes.hasOwnProperty(key) && Indexes) {
                        if (Indexes[key][name] instanceof Array) {
                            if (!callback && !mustRemove) {
                                console.error('this ' + name + ' is has many callback', Indexes[key][name]);
                            }
                            else {
                                if (Indexes[key][name].length <= 1 || !callback && mustRemove) {
                                    delete Indexes[key][name];
                                    result = true;
                                }
                                else if (callback) {
                                    let index = Indexes[key][name].indexOf(callback);
                                    index >= 0 && Indexes[key][name].splice(index, 1);
                                    if (!result) {
                                        result = index >= 0;
                                    }
                                }
                            }
                        }
                        else {
                            result = true;
                            delete Indexes[key][name];
                        }
                    }
                }
            }
        }
        return result;
    }
    // 添加指令
    push(instruction, name = 'default', triggerType, zIndex = 0) {
        let resultInstruction;
        if (typeof instruction === 'function') {
            resultInstruction = {
                trigger: instruction,
                name,
                zIndex,
                triggerType
            };
        }
        else {
            resultInstruction = instruction;
            name = resultInstruction.name || name;
        }
        // 设置zIndex执行表
        resultInstruction.zIndex = resultInstruction.zIndex === undefined ? 0 : resultInstruction.zIndex;
        // 设置触发类型
        if (resultInstruction.triggerType === undefined) {
            resultInstruction.triggerType = "has";
        }
        // 获取类型
        let type = resultInstruction.type || "front";
        // 执行添加
        if (this.container === undefined)
            this.container = {};
        if (this.container[type] === undefined) {
            this.container[type] = {};
        }
        if (this.container[type][resultInstruction.triggerType] === undefined) {
            this.container[type][resultInstruction.triggerType] = {};
        }
        // 创建索引
        let Indexes = this.container[type][resultInstruction.triggerType];
        if (Indexes[name] === undefined) {
            Indexes[name] = resultInstruction;
        }
        else {
            if (!(Indexes[name] instanceof Array)) {
                Indexes[name] = [Indexes[name]];
            }
            Indexes[name].push(resultInstruction);
        }
        return resultInstruction;
    }
    // 根据提供的key 查询可被执行的指令
    search(data, arg, type = "front") {
        // 如果没有指令
        if (this.container === undefined) {
            return [];
        }
        // 获取
        let Indexes = this.container[type];
        // 如果没有此类型返回空
        if (Indexes === undefined) {
            return [];
        }
        let resultData = [];
        // 否则执行检测跳过执行
        if (Indexes.skip) {
            let skipIndexes = Indexes.skip;
            for (let key in skipIndexes) {
                if (skipIndexes.hasOwnProperty(key)) {
                    let useResultData = this.searchTriggerWhere(skipIndexes[key], arg);
                    if (useResultData && useResultData.length > 0) {
                        resultData.push(...useResultData);
                    }
                }
            }
        }
        // 查找拥有
        if (Indexes.has) {
            let keys = Object.keys(data);
            let hasIndexes = Indexes.has;
            keys.map((item) => {
                if (!hasIndexes[item])
                    return;
                let useResultData = this.searchTriggerWhere(hasIndexes[item], arg);
                if (useResultData && useResultData.length > 0) {
                    resultData.push(...useResultData);
                }
            });
        }
        // 执行排序
        if (resultData.length > 1) {
            resultData.sort(function (leftItem, rightItem) {
                return leftItem.zIndex > rightItem.zIndex ? -1 : 1;
            });
        }
        return resultData;
    }
    // 触发
    trigger(data, arg) {
        if (data) {
            return data.map((item) => item.trigger(arg));
        }
    }
    // 触发 + 搜索
    searchTrigger(data, arg, type = "front") {
        return this.trigger(this.search(data, arg, type));
    }
    // 查询可触发条件的where
    searchTriggerWhere(triggers, arg) {
        if (triggers instanceof Array) {
            return triggers.filter((item) => item.where === undefined || item.where(arg));
        }
        else {
            if (triggers.where === undefined || triggers.where(arg)) {
                return [triggers];
            }
        }
        return undefined;
    }
}