nodejs 函数 ：html2js

var fs = require("fs");
var path = require("path");


function propStringToMap(ss1) {
    var propsMap = {};
    var propsLength = 0;
    var firstProp = null;
    var xa = ss1.split(/["'][s]+/);
    for (var j = 0; j < xa.length; j++) {
        var xaj = xa[j];
        var xajPair = xaj.split('=');
        if (xajPair.length === 2) {
            var key = (xajPair[0] || "").trim();
            var value = xajPair[1] || "";
            if (key) {
                var value1 = value.replace(/['"]/gm, '');
                value1 = value1.trim();
                propsMap[key] = value1;
                propsLength++;
                if (!firstProp) {
                    firstProp = key;
                }
            }
        }
    }


    return {
        propsMap: propsMap,
        propsLength: propsLength,
        firstProp: firstProp
    };
}


function parseString2Html(html) {

    var templateArray = html.split('<string2-template');

    var resultObject = {};
    for (var i = 0; i < templateArray.length; i++) {
        var str = (templateArray[i] || "").trim();
        if (str.length > 0) {
            var index = str.indexOf('>');
            var ss1 = str.substring(0, index);
            var ss2 = str.substring(index + 1, str.length);
            ss1 = ss1.replace(/\/mg, '');
            ss1 = ss1.trim();

            var templateContent = ss2.replace(/</string2-template>$/i, '');
            templateContent = templateContent.trim();
            templateContent = templateContent.replace(/s+/gm, ' ');

            var propsResult = propStringToMap(ss1);

            var propsMap = propsResult.propsMap;
            var propsLength = propsResult.propsLength;
            var firstProp = propsResult.firstProp;

            var templateKey = propsMap['id'] || propsMap[firstProp];

            if (propsLength === 1) {
                resultObject[templateKey] = templateContent;
            }

            else if (propsLength > 1) {
                resultObject[templateKey] = {
                    content: templateContent,
                    propsMap: propsMap,
                    propsLength: propsLength,
                    firstProp: firstProp
                };
            }
        }
    }


    return resultObject;

}


function extendObject(a, b) {
    for (var key in b) {
        if (b.hasOwnProperty(key)) {
            a[key] = b[key];
        }
    }
    return a;
}

function htmlArray2js(dirPath, htmlPathArray) {
    var p = Promise.resolve();

    for (var i = 0; i < htmlPathArray.length; i++) {
        var htmlPath = (htmlPathArray[i] || '').trim();
        if (htmlPath) {
            p = p.then((function (dirPath, htmlPath) {
                return function (result) {
                    result = result || {};
                    return new Promise(function (resolve, reject) {
                        var filePath = path.resolve(dirPath, htmlPath);
                        console.log(dirPath, filePath.toString());

                        if (filePath.indexOf(dirPath) !== 0) {
                            var errorMsg = {};
                            errorMsg["read_file_error_" + htmlPath] = "illegal access";
                            result = extendObject(result, errorMsg);
                            resolve(result);
                            return;
                        }

                        fs.readFile(filePath, "utf-8", function (err, html) {
                            if (err) {
                                var errorMsg = {};
                                errorMsg["read_file_error_" + htmlPath] = "read file error";
                                result = extendObject(result, errorMsg);
                                resolve(result);
                            } else {
                                var htmlObject = parseString2Html(html);
                                result = extendObject(result, htmlObject);
                                resolve(result);
                            }
                        });
                    });
                }
            })(dirPath, htmlPath));
        }
    }
    return p;
}


function getHtml2JsContent(dirPath, htmls) {
    var htmlPathArray = htmls.split(',');
    var jsPromise = htmlArray2js(dirPath, htmlPathArray);
    return jsPromise.then(function (js) {
        var jsStr = JSON.stringify(js);
        return jsStr;
    });
}


var JS_STR_CACHE = {};


/**
 *

 app.get('/html2js', html2jsCombo(path.join(__dirname, '../static'),{
    cache:false
 }));


 <script src="/html2js?output=html2js&htmls=bixun/html/test.shtml"></script>

 * @param dirPath
 * @param config
 * @returns {Function}
 */
module.exports = function html2jsCombo(dirPath, config) {
    return function (req, res) {
        var req_query = req.query;
        var htmls = req_query.html;
        var output = req_query.output;

        var promise = null;
        if (config.cache && JS_STR_CACHE[htmls]) {
            promise = Promise.resolve(JS_STR_CACHE[htmls]);
        } else {
            promise = getHtml2JsContent(dirPath, htmls);
            if (config.cache) {
                promise = promise.then(function (jsStr) {
                    JS_STR_CACHE[htmls] = jsStr;
                    return jsStr;
                });
            }
        }

        promise.then(function (jsStr) {
            if (output) {
                jsStr = "var " + output + " = " + jsStr;
                res.writeHead(200, {
                    'Content-Type': 'application/javascript; charset=utf-8',
                    "Cache-Control": "public, max-age=31536000"
                });
            } else {
                res.writeHead(200, {
                    'Content-Type': 'application/json'
                });
            }
            res.write(jsStr);
            res.end();
        });
    }
};