mtl-js-sdk/lib/common/nativeExecProxy.js

ynf-fw-mtl-api

/*
 * @Author: wangyingliang@yonyou.com
 * @Date: 2024-07-22 15:45:20
 * @LastEditors: wangyingliang wangyingliang@yonyou.com
 * @LastEditTime: 2024-07-22 16:06:18
 * @FilePath: /mtl-api-project/src/common/nativeExecProxy.js
 * @Description: 原生方法代理
 * Copyright (c) 2024 by Yonyou, All Rights Reserved.
 */
/**
 * 由于原生只能通过方法名(String) 回调，所以将 api 中 success/fail/complete 回调
 * 封装到 callback 中，并用一个 uuid 与 callback 关联。
 */
import uuid from './uuid'
const CALLBACK_TYPE_COMMON = 0;
const CALLBACK_TYPE_EXTRA = 1;

let _callbackCaches = {};

function setCallback({ funcName, success, fail, complete }) {
    let callbackId = uuid(8);
    let callbackInfo = {
        type: CALLBACK_TYPE_COMMON,
        funcName,
        funcGroup: { success, fail, complete }
    };
    _callbackCaches[callbackId] = callbackInfo;
    return callbackId;
}

// 处理 params 参数中传递的额外回调，如多端协同中等待授权申请回应。
function setExtraCallback(func, funcName) {
    let callbackId = uuid(8);
    let callbackInfo = {
        type: CALLBACK_TYPE_EXTRA,
        funcName,
        func: func
    };
    _callbackCaches[callbackId] = callbackInfo;
    return callbackId;
}

window.mtl_handleCallback = function (result) {
    const { callbackId, keepCallback, code, msg: message, data } = result;
    let callbackInfo = _callbackCaches[callbackId];

    if (callbackInfo.type === CALLBACK_TYPE_COMMON) {
        let { success, fail, complete } = callbackInfo.funcGroup;
        if (code == 0) {
            success && success(data);
        } else {
            fail && fail({ code, message });
        }
        complete && complete({ code, message, data });
    } else if (callbackInfo.type === CALLBACK_TYPE_EXTRA) {
        let { func } = callbackInfo;
        func && func(data);
    }
    if (!keepCallback) {
        delete _callbackCaches[callbackId];
    }
};

// 使用 callbackId 替换参数中的 function 类型属性
function recurseReplaceFunc(object) {
    if (typeof object === "function") {
        return setExtraCallback(object);
    }
    if (typeof object === "object") {
        if (object instanceof Array) {
            return object.map(o => recurseReplaceFunc(o));
        }
        let copy = {};
        for (const key in object) {
            if (object.hasOwnProperty(key)) {
                const element = object[key];
                copy[key] = recurseReplaceFunc(element);
            }
        }
        return copy;
    }
    return object;
}

function proxy(func) {
    return function (object = {}) {
        const isFunc = typeof object === "function";
        let _object = isFunc ? {} : { ...object };
        delete _object.success;
        delete _object.fail;
        delete _object.complete;
        if (_object.callback && _object.callback.length > 0) {
            _object.registerCallback = "mtl_registerCallback()";
            _object.callbackName = _object.callback;
        }
        if (_object.mtlRegisterCallbackName && _object.mtlRegisterCallbackName.length > 0) {
            return func(_object);
        }
        _object.callback = "mtl_handleCallback()";
        _object.callbackId = setCallback(isFunc ? { success: object } : object);
        return func(recurseReplaceFunc(_object));
    };
}
export default proxy;