mtl-js-sdk/lib/common/modulemapper.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:05:26
 * @FilePath: /mtl-api-project/src/common/modulemapper.js
 * @Description: builder
 * Copyright (c) 2024 by Yonyou, All Rights Reserved.
 */
import builder from './builder'

let symbolList;

function addEntry(strategy, module, symbolPath) {
    symbolList.push(strategy, module, symbolPath);
}

function prepareNamespace(symbolPath, context) {
    if (!symbolPath) {
        return context;
    }
    let parts = symbolPath.split('.');
    let cur = context;
    for (let i = 0, part; part = parts[i]; ++i) {
        cur = cur[part] = cur[part] || {};
    }
    return cur;
}

let mapper = {};

mapper.reset = function () {
    symbolList = [];
};

mapper.addEntry = addEntry;

mapper.clobbers = function (module, symbolPath) {
    addEntry('c', module, symbolPath);
};

mapper.merges = function (module, symbolPath) {
    addEntry('m', module, symbolPath);
};

mapper.uniques = function (module, symbolPath) {
    addEntry('u', module, symbolPath);
};

mapper.extend = function (module, symbolPath) {
    addEntry('e', module, symbolPath)
};

mapper.mapModules = function (context) {
    let origSymbols = {};
    context.MTL_origSymbols = origSymbols;
    for (let i = 0, len = symbolList.length; i < len; i += 3) {
        let strategy = symbolList[i];
        let module = symbolList[i + 1];

        let symbolPath = symbolList[i + 2];
        let lastDot = symbolPath.lastIndexOf('.');
        let namespace = symbolPath.substr(0, lastDot);
        let lastName = symbolPath.substr(lastDot + 1);

        let parentObj = prepareNamespace(namespace, context);
        let target = parentObj[lastName];

        if (strategy === 'u' && target) {
            console.log('Error: Scaling failure, ' + symbolPath + ' already exist。')
        }
        else if (strategy === 'm' && target) {
            builder.recursiveMerge(target, module);
        }
        else if (strategy === 'e' && target) {
            builder.recursiveMerge(target, module)
        }
        else {
            if (!(symbolPath in origSymbols)) {
                origSymbols[symbolPath] = target;
            }
            builder.assignGetter(parentObj, lastName, module);
        }
    }
};

mapper.getOriginalSymbol = function (context, symbolPath) {
    let origSymbols = context.MTL_origSymbols;
    if (origSymbols && (symbolPath in origSymbols)) {
        return origSymbols[symbolPath];
    }
    let parts = symbolPath.split('.');
    let obj = context;
    for (let i = 0; i < parts.length; ++i) {
        obj = obj && obj[parts[i]];
    }
    return obj;
};

mapper.reset();

export default mapper;