mk-meta-engine/lib/common.js

元数据化引擎，在mk-app-loader实现的应用隔离基础上，实现可以用json元数据描述界面模型，并提供了action、reducer的基础函数和monkeyKing组件.

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

exports.setMeta = setMeta;
exports.setMetaForce = setMetaForce;
exports.getMeta = getMeta;
exports.getField = getField;
exports.getFields = getFields;
exports.setField = setField;
exports.setFields = setFields;
exports.updateField = updateField;

var _immutable = require('immutable');

var _immutable2 = _interopRequireDefault(_immutable);

var _mkUtils = require('mk-utils');

var _mkUtils2 = _interopRequireDefault(_mkUtils);

var _templateFactory = require('./templateFactory');

var _templateFactory2 = _interopRequireDefault(_templateFactory);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var existsParamsInPath = _mkUtils.path.existsParamsInPath,
    parsePath = _mkUtils.path.parsePath;


var cache = { meta: (0, _immutable.Map)() };

window['__getCache'] = function () {
    return cache;
};

function setMeta(appInfo) {

    if (!appInfo || !appInfo.meta) return;

    var appName = appInfo.name;

    if (cache.meta.has(appName)) return;

    setMetaForce(appName, appInfo.meta);
}

function setMetaForce(appName, meta) {
    if (!appName || !meta) return;

    meta = (0, _immutable.fromJS)(meta);

    meta = parseMetaTemplate(meta);

    cache.meta = cache.meta.setIn([appName, 'meta'], meta).setIn([appName, 'metaMap'], parseMeta(meta));
}

function getMeta(appInfo, fullpath, propertys) {
    //path空取整个meta
    if (!fullpath) return cache.meta.getIn([appInfo.name, 'meta']).toJS();

    var parsedPath = parsePath(fullpath),
        vars = parsedPath.vars,
        metaMap = cache.meta.getIn([appInfo.name, 'metaMap']),
        meta = cache.meta.getIn([appInfo.name, 'meta']);

    var path = metaMap.get(parsedPath.path);

    var currentMeta = path ? meta.getIn(path.split('.')) : meta;

    //属性空，获取该路径下所有属性
    if (!propertys) return currentMeta.toJS();

    var ret = {};

    //属性为数组，遍历获取
    if (propertys instanceof Array) {
        var i, p;

        for (i = 0; p = propertys[i++];) {
            var val = currentMeta.getIn(p.split('.'));
            ret[p] = val && val.toJS ? val.toJS() : val;
        }

        /*
        propertys.forEach(p => {
            let val = currentMeta.getIn(p.split('.'))
            //immutable值，直接toJS()
            ret[p] = (val && val.toJS) ? val.toJS() : val
        })*/

        return ret;
    }

    //属性为字符串，直接获取
    if (typeof propertys == 'string') {
        var _val = currentMeta.getIn(propertys.split('.'));
        return _val && _val.toJS ? _val.toJS() : _val;
    }
}

function getField(state, fieldPath) {
    if (!fieldPath) {
        return state.get('data');
    }

    if (fieldPath instanceof Array) {
        return state.getIn(fieldPath);
    } else {
        return state.getIn(fieldPath.split('.'));
    }
}

function getFields(state, fieldPaths) {
    var ret = {};
    fieldPaths.forEach(function (o) {
        return ret[o] = getField(state, o);
    });
    return ret;
}

function setField(state, fieldPath, value) {
    if (fieldPath instanceof Array) {
        return state.setIn(fieldPath, value);
    } else {
        return state.setIn(fieldPath.split('.'), value);
    }
}

function setFields(state, values) {
    var keys = (0, _keys2.default)(values),
        i,
        key;

    for (i = 0; key = keys[i++];) {
        state = setField(state, key, values[key]);
    }
    return state;
}

function updateField(state, fieldPath, fn) {
    if (fieldPath instanceof Array) {
        return state.updateIn(fieldPath, fn);
    } else {
        return state.updateIn(fieldPath.split('.'), fn);
    }
}

function isComponent(meta) {
    return (typeof meta === 'undefined' ? 'undefined' : (0, _typeof3.default)(meta)) == 'object' && !!meta.name && !!meta.component;
}

function parseMetaTemplate(meta) {
    var templates = [];

    var parseProp = function parseProp(propValue, path) {
        if (!(propValue instanceof _immutable2.default.Map)) {
            return;
        }
        if (propValue.get('component')) {
            var component = _mkUtils2.default.string.trim(propValue.get('component'));
            if (component.substring(0, 2) == '##') {
                var template = _templateFactory2.default.getTemplate(component.substr(2));
                if (template) {
                    templates.push([path, (0, _immutable.fromJS)(template(propValue.toJS()))]);
                    return;
                }
            }
        }

        propValue.keySeq().toArray().forEach(function (p) {
            var v = propValue.get(p);
            if (v instanceof _immutable2.default.List) {
                v.forEach(function (c, index) {
                    var currentPath = path ? path + '.' + p + '.' + index : p + '.' + index;
                    parseProp(c, currentPath);
                });
            } else {
                var currentPath = path ? path + '.' + p : p;
                parseProp(v, currentPath);
            }
        });
    };
    parseProp(meta, '');
    templates.forEach(function (t) {
        var seg = t[0].split('.');
        if (t[1] instanceof _immutable2.default.List && meta.getIn(seg.slice(0, seg.length - 1)) instanceof _immutable2.default.List) {
            var index = seg.pop();
            meta = meta.updateIn(seg, function (ll) {
                ll = ll.remove(index);

                t[1].forEach(function (o) {
                    ll = ll.insert(index, o);
                    index++;
                });
                return ll;
            });
        } else {
            meta = meta.setIn(seg, t[1]);
        }
    });
    return meta;
}

function parseMeta(meta) {
    var ret = (0, _immutable.Map)();
    var parseProp = function parseProp(propValue, parentPath, parentRealPath) {
        if (!(propValue instanceof _immutable2.default.Map)) {
            return;
        }
        if (propValue.get('name') && propValue.get('component')) {
            var name = _mkUtils2.default.string.trim(propValue.get('name'));
            parentPath = parentPath ? parentPath + '.' + name : name;
            ret = ret.set(parentPath, parentRealPath);
        }

        propValue.keySeq().toArray().forEach(function (p) {

            var v = propValue.get(p),
                currentPath = parentPath ? parentPath + '.' + p : p;
            if (v instanceof _immutable2.default.List) {
                v.forEach(function (c, index) {
                    var currentRealPath = parentRealPath ? parentRealPath + '.' + p + '.' + index : p + '.' + index;
                    parseProp(c, '' + currentPath, currentRealPath);
                });
            } else {
                var currentRealPath = parentRealPath ? parentRealPath + '.' + p : p;
                parseProp(v, '' + currentPath, currentRealPath);
            }
        });
    };

    parseProp(meta, '', '');
    return ret;
}